diff --git a/Tests/BarcodeUtilitiesTests.cs b/Tests/BarcodeUtilitiesTests.cs
new file mode 100644
index 00000000..169f8e67
--- /dev/null
+++ b/Tests/BarcodeUtilitiesTests.cs
@@ -0,0 +1,44 @@
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Runtime.InteropServices.WindowsRuntime;
+using Text_Grab;
+using Text_Grab.Models;
+using Text_Grab.Utilities;
+using Windows.Storage.Streams;
+
+namespace Tests;
+
+public class BarcodeUtilitiesTests
+{
+    [Fact]
+    public void TryToReadBarcodes_WithDisposedBitmap_ReturnsEmptyBarcodeOutput()
+    {
+        Bitmap disposedBitmap = new(8, 8);
+        disposedBitmap.Dispose();
+
+        OcrOutput result = BarcodeUtilities.TryToReadBarcodes(disposedBitmap);
+
+        Assert.Equal(OcrOutputKind.Barcode, result.Kind);
+        Assert.Equal(string.Empty, result.RawOutput);
+    }
+
+    [Fact]
+    public async Task GetBitmapFromIRandomAccessStream_ReturnsBitmapIndependentOfSourceStream()
+    {
+        using Bitmap sourceBitmap = new(8, 8);
+        sourceBitmap.SetPixel(0, 0, Color.Red);
+
+        using MemoryStream memoryStream = new();
+        sourceBitmap.Save(memoryStream, ImageFormat.Png);
+
+        using InMemoryRandomAccessStream randomAccessStream = new();
+        _ = await randomAccessStream.WriteAsync(memoryStream.ToArray().AsBuffer());
+
+        Bitmap clonedBitmap = ImageMethods.GetBitmapFromIRandomAccessStream(randomAccessStream);
+
+        Assert.Equal(8, clonedBitmap.Width);
+        Assert.Equal(8, clonedBitmap.Height);
+        Assert.Equal(Color.Red.ToArgb(), clonedBitmap.GetPixel(0, 0).ToArgb());
+    }
+}
diff --git a/Tests/FreeformCaptureUtilitiesTests.cs b/Tests/FreeformCaptureUtilitiesTests.cs
new file mode 100644
index 00000000..3cf860ff
--- /dev/null
+++ b/Tests/FreeformCaptureUtilitiesTests.cs
@@ -0,0 +1,63 @@
+using System.Drawing;
+using System.Windows;
+using System.Windows.Media;
+using Text_Grab.Utilities;
+using Point = System.Windows.Point;
+
+namespace Tests;
+
+public class FreeformCaptureUtilitiesTests
+{
+    [WpfFact]
+    public void GetBounds_RoundsOutwardToIncludeAllPoints()
+    {
+        List<Point> points =
+        [
+            new(1.2, 2.8),
+            new(10.1, 4.2),
+            new(4.6, 9.9)
+        ];
+
+        Rect bounds = FreeformCaptureUtilities.GetBounds(points);
+
+        Assert.Equal(new Rect(new Point(1, 2), new Point(11, 10)), bounds);
+    }
+
+    [WpfFact]
+    public void BuildGeometry_CreatesClosedFigure()
+    {
+        List<Point> points =
+        [
+            new(0, 0),
+            new(4, 0),
+            new(4, 4)
+        ];
+
+        PathGeometry geometry = FreeformCaptureUtilities.BuildGeometry(points);
+
+        Assert.Single(geometry.Figures);
+        Assert.Equal(points[0], geometry.Figures[0].StartPoint);
+        Assert.True(geometry.Figures[0].IsClosed);
+        Assert.Equal(2, geometry.Figures[0].Segments.Count);
+    }
+
+    [WpfFact]
+    public void CreateMaskedBitmap_WhitensPixelsOutsideThePolygon()
+    {
+        using Bitmap sourceBitmap = new(10, 10);
+        using Graphics graphics = Graphics.FromImage(sourceBitmap);
+        graphics.Clear(System.Drawing.Color.Black);
+
+        using Bitmap maskedBitmap = FreeformCaptureUtilities.CreateMaskedBitmap(
+            sourceBitmap,
+            [
+                new Point(2, 2),
+                new Point(7, 2),
+                new Point(7, 7),
+                new Point(2, 7)
+            ]);
+
+        Assert.Equal(System.Drawing.Color.Gray.ToArgb(), maskedBitmap.GetPixel(0, 0).ToArgb());
+        Assert.Equal(System.Drawing.Color.Black.ToArgb(), maskedBitmap.GetPixel(4, 4).ToArgb());
+    }
+}
diff --git a/Tests/FullscreenCaptureResultTests.cs b/Tests/FullscreenCaptureResultTests.cs
new file mode 100644
index 00000000..c2eaf52e
--- /dev/null
+++ b/Tests/FullscreenCaptureResultTests.cs
@@ -0,0 +1,32 @@
+using System.Windows;
+using Text_Grab;
+using Text_Grab.Models;
+
+namespace Tests;
+
+public class FullscreenCaptureResultTests
+{
+    [Theory]
+    [InlineData(FsgSelectionStyle.Region, true)]
+    [InlineData(FsgSelectionStyle.Window, true)]
+    [InlineData(FsgSelectionStyle.Freeform, false)]
+    [InlineData(FsgSelectionStyle.AdjustAfter, true)]
+    public void SupportsTemplateActions_MatchesSelectionStyle(FsgSelectionStyle selectionStyle, bool expected)
+    {
+        FullscreenCaptureResult result = new(selectionStyle, Rect.Empty);
+
+        Assert.Equal(expected, result.SupportsTemplateActions);
+    }
+
+    [Theory]
+    [InlineData(FsgSelectionStyle.Region, true)]
+    [InlineData(FsgSelectionStyle.Window, false)]
+    [InlineData(FsgSelectionStyle.Freeform, false)]
+    [InlineData(FsgSelectionStyle.AdjustAfter, true)]
+    public void SupportsPreviousRegionReplay_MatchesSelectionStyle(FsgSelectionStyle selectionStyle, bool expected)
+    {
+        FullscreenCaptureResult result = new(selectionStyle, Rect.Empty);
+
+        Assert.Equal(expected, result.SupportsPreviousRegionReplay);
+    }
+}
diff --git a/Tests/FullscreenGrabPostGrabActionTests.cs b/Tests/FullscreenGrabPostGrabActionTests.cs
new file mode 100644
index 00000000..e40bcc4e
--- /dev/null
+++ b/Tests/FullscreenGrabPostGrabActionTests.cs
@@ -0,0 +1,127 @@
+using System.Windows.Controls;
+using Text_Grab.Models;
+using Text_Grab.Views;
+using Wpf.Ui.Controls;
+using MenuItem = System.Windows.Controls.MenuItem;
+
+namespace Tests;
+
+public class FullscreenGrabPostGrabActionTests
+{
+    [Fact]
+    public void GetPostGrabActionKey_UsesTemplateIdForTemplateActions()
+    {
+        ButtonInfo action = new("Template Action", "ApplyTemplate_Click", SymbolRegular.Apps24, DefaultCheckState.Off)
+        {
+            TemplateId = "template-123"
+        };
+
+        string key = FullscreenGrab.GetPostGrabActionKey(action);
+
+        Assert.Equal("template:template-123", key);
+    }
+
+    [Fact]
+    public void GetPostGrabActionKey_FallsBackToButtonTextWhenClickEventMissing()
+    {
+        ButtonInfo action = new()
+        {
+            ButtonText = "Custom action"
+        };
+
+        string key = FullscreenGrab.GetPostGrabActionKey(action);
+
+        Assert.Equal("text:Custom action", key);
+    }
+
+    [WpfFact]
+    public void GetActionablePostGrabMenuItems_ExcludesUtilityEntriesAndPreservesOrder()
+    {
+        ContextMenu contextMenu = new();
+        MenuItem firstAction = new()
+        {
+            Header = "First action",
+            Tag = new ButtonInfo("First action", "First_Click", SymbolRegular.Apps24, DefaultCheckState.Off)
+        };
+        MenuItem utilityItem = new()
+        {
+            Header = "Customize",
+            Tag = "EditPostGrabActions"
+        };
+        MenuItem secondAction = new()
+        {
+            Header = "Second action",
+            Tag = new ButtonInfo("Second action", "Second_Click", SymbolRegular.Apps24, DefaultCheckState.Off)
+        };
+
+        contextMenu.Items.Add(firstAction);
+        contextMenu.Items.Add(new Separator());
+        contextMenu.Items.Add(utilityItem);
+        contextMenu.Items.Add(secondAction);
+        contextMenu.Items.Add(new MenuItem
+        {
+            Header = "Close this menu",
+            Tag = "ClosePostGrabMenu"
+        });
+
+        List<MenuItem> actionableItems = FullscreenGrab.GetActionablePostGrabMenuItems(contextMenu);
+
+        Assert.Collection(actionableItems,
+            item => Assert.Same(firstAction, item),
+            item => Assert.Same(secondAction, item));
+    }
+
+    [WpfFact]
+    public void BuildPostGrabActionSnapshot_KeepsChangedTemplateCheckedAndUnchecksOthers()
+    {
+        ButtonInfo regularAction = new("Trim each line", "TrimEachLine_Click", SymbolRegular.Apps24, DefaultCheckState.Off);
+        ButtonInfo firstTemplate = new("Template A", "ApplyTemplate_Click", SymbolRegular.Apps24, DefaultCheckState.Off)
+        {
+            TemplateId = "template-a"
+        };
+        ButtonInfo secondTemplate = new("Template B", "ApplyTemplate_Click", SymbolRegular.Apps24, DefaultCheckState.Off)
+        {
+            TemplateId = "template-b"
+        };
+
+        Dictionary<string, bool> snapshot = FullscreenGrab.BuildPostGrabActionSnapshot(
+            [
+                new MenuItem { Tag = regularAction, IsCheckable = true, IsChecked = true },
+                new MenuItem { Tag = firstTemplate, IsCheckable = true, IsChecked = true },
+                new MenuItem { Tag = secondTemplate, IsCheckable = true, IsChecked = false }
+            ],
+            FullscreenGrab.GetPostGrabActionKey(secondTemplate),
+            true);
+
+        Assert.True(snapshot[FullscreenGrab.GetPostGrabActionKey(regularAction)]);
+        Assert.False(snapshot[FullscreenGrab.GetPostGrabActionKey(firstTemplate)]);
+        Assert.True(snapshot[FullscreenGrab.GetPostGrabActionKey(secondTemplate)]);
+    }
+
+    [Fact]
+    public void ShouldPersistLastUsedState_ForForcedSourceAction_ReturnsTrue()
+    {
+        ButtonInfo lastUsedAction = new("Remove duplicate lines", "RemoveDuplicateLines_Click", SymbolRegular.Apps24, DefaultCheckState.LastUsed);
+
+        bool shouldPersist = FullscreenGrab.ShouldPersistLastUsedState(
+            lastUsedAction,
+            previousChecked: true,
+            isChecked: true,
+            forcePersistActionKey: FullscreenGrab.GetPostGrabActionKey(lastUsedAction));
+
+        Assert.True(shouldPersist);
+    }
+
+    [Fact]
+    public void ShouldPersistLastUsedState_DoesNotPersistUnchangedNonSourceAction()
+    {
+        ButtonInfo lastUsedAction = new("Remove duplicate lines", "RemoveDuplicateLines_Click", SymbolRegular.Apps24, DefaultCheckState.LastUsed);
+
+        bool shouldPersist = FullscreenGrab.ShouldPersistLastUsedState(
+            lastUsedAction,
+            previousChecked: true,
+            isChecked: true);
+
+        Assert.False(shouldPersist);
+    }
+}
diff --git a/Tests/FullscreenGrabSelectionStyleTests.cs b/Tests/FullscreenGrabSelectionStyleTests.cs
new file mode 100644
index 00000000..9ab30270
--- /dev/null
+++ b/Tests/FullscreenGrabSelectionStyleTests.cs
@@ -0,0 +1,74 @@
+using System.Windows;
+using Text_Grab;
+using Text_Grab.Models;
+using Text_Grab.Views;
+
+namespace Tests;
+
+public class FullscreenGrabSelectionStyleTests
+{
+    [Theory]
+    [InlineData(FsgSelectionStyle.Window, false, true)]
+    [InlineData(FsgSelectionStyle.Window, true, true)]
+    [InlineData(FsgSelectionStyle.Region, true, true)]
+    [InlineData(FsgSelectionStyle.Region, false, false)]
+    [InlineData(FsgSelectionStyle.Freeform, false, false)]
+    [InlineData(FsgSelectionStyle.AdjustAfter, false, false)]
+    public void ShouldKeepTopToolbarVisible_MatchesSelectionState(
+        FsgSelectionStyle selectionStyle,
+        bool isAwaitingAdjustAfterCommit,
+        bool expected)
+    {
+        bool shouldKeepVisible = FullscreenGrab.ShouldKeepTopToolbarVisible(
+            selectionStyle,
+            isAwaitingAdjustAfterCommit);
+
+        Assert.Equal(expected, shouldKeepVisible);
+    }
+
+    [Theory]
+    [InlineData(FsgSelectionStyle.Region, true)]
+    [InlineData(FsgSelectionStyle.Window, false)]
+    [InlineData(FsgSelectionStyle.Freeform, false)]
+    [InlineData(FsgSelectionStyle.AdjustAfter, true)]
+    public void ShouldUseOverlayCutout_MatchesSelectionStyle(FsgSelectionStyle selectionStyle, bool expected)
+    {
+        bool shouldUseCutout = FullscreenGrab.ShouldUseOverlayCutout(selectionStyle);
+
+        Assert.Equal(expected, shouldUseCutout);
+    }
+
+    [Theory]
+    [InlineData(FsgSelectionStyle.Region, true)]
+    [InlineData(FsgSelectionStyle.Window, false)]
+    [InlineData(FsgSelectionStyle.Freeform, false)]
+    [InlineData(FsgSelectionStyle.AdjustAfter, true)]
+    public void ShouldDrawSelectionOutline_MatchesSelectionStyle(FsgSelectionStyle selectionStyle, bool expected)
+    {
+        bool shouldDrawOutline = FullscreenGrab.ShouldDrawSelectionOutline(selectionStyle);
+
+        Assert.Equal(expected, shouldDrawOutline);
+    }
+
+    [Fact]
+    public void ShouldCommitWindowSelection_RequiresSameWindowHandleOnMouseUp()
+    {
+        WindowSelectionCandidate pressedCandidate = new((nint)1, new Rect(0, 0, 40, 40), "Target", 100);
+        WindowSelectionCandidate releasedSameCandidate = new((nint)1, new Rect(0, 0, 40, 40), "Target", 100);
+        WindowSelectionCandidate releasedDifferentCandidate = new((nint)2, new Rect(0, 0, 40, 40), "Other", 200);
+
+        Assert.True(FullscreenGrab.ShouldCommitWindowSelection(pressedCandidate, releasedSameCandidate));
+        Assert.False(FullscreenGrab.ShouldCommitWindowSelection(pressedCandidate, releasedDifferentCandidate));
+        Assert.False(FullscreenGrab.ShouldCommitWindowSelection(pressedCandidate, null));
+        Assert.False(FullscreenGrab.ShouldCommitWindowSelection(null, releasedSameCandidate));
+    }
+
+    [Fact]
+    public void WindowSelectionCandidate_DisplayText_UsesFallbacksWhenMetadataMissing()
+    {
+        WindowSelectionCandidate candidate = new((nint)1, new Rect(0, 0, 40, 40), string.Empty, 100);
+
+        Assert.Equal("Application", candidate.DisplayAppName);
+        Assert.Equal("Untitled window", candidate.DisplayTitle);
+    }
+}
diff --git a/Tests/FullscreenGrabZoomCaptureTests.cs b/Tests/FullscreenGrabZoomCaptureTests.cs
new file mode 100644
index 00000000..df437ebb
--- /dev/null
+++ b/Tests/FullscreenGrabZoomCaptureTests.cs
@@ -0,0 +1,90 @@
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using Text_Grab.Views;
+
+namespace Tests;
+
+public class FullscreenGrabZoomCaptureTests
+{
+    [Fact]
+    public void TryGetBitmapCropRectForSelection_UsesSelectionRectWithoutZoom()
+    {
+        bool didCreateCrop = FullscreenGrab.TryGetBitmapCropRectForSelection(
+            new Rect(10, 20, 30, 40),
+            Matrix.Identity,
+            null,
+            200,
+            200,
+            out Int32Rect cropRect);
+
+        Assert.True(didCreateCrop);
+        Assert.Equal(10, cropRect.X);
+        Assert.Equal(20, cropRect.Y);
+        Assert.Equal(30, cropRect.Width);
+        Assert.Equal(40, cropRect.Height);
+    }
+
+    [Fact]
+    public void TryGetBitmapCropRectForSelection_MapsZoomedSelectionBackToFrozenBitmap()
+    {
+        TransformGroup zoomTransform = new();
+        zoomTransform.Children.Add(new ScaleTransform(2, 2, 50, 50));
+        zoomTransform.Children.Add(new TranslateTransform(-10, 15));
+
+        Rect sourceRect = new(40, 50, 20, 10);
+        Rect displayedSelectionRect = TransformRect(sourceRect, zoomTransform.Value);
+
+        bool didCreateCrop = FullscreenGrab.TryGetBitmapCropRectForSelection(
+            displayedSelectionRect,
+            Matrix.Identity,
+            zoomTransform,
+            200,
+            200,
+            out Int32Rect cropRect);
+
+        Assert.True(didCreateCrop);
+        Assert.Equal(40, cropRect.X);
+        Assert.Equal(50, cropRect.Y);
+        Assert.Equal(20, cropRect.Width);
+        Assert.Equal(10, cropRect.Height);
+    }
+
+    [Fact]
+    public void TryGetBitmapCropRectForSelection_AppliesDeviceScalingAfterUndoingZoom()
+    {
+        ScaleTransform zoomTransform = new(2, 2);
+
+        bool didCreateCrop = FullscreenGrab.TryGetBitmapCropRectForSelection(
+            new Rect(20, 30, 40, 50),
+            new Matrix(1.5, 0, 0, 1.5, 0, 0),
+            zoomTransform,
+            200,
+            200,
+            out Int32Rect cropRect);
+
+        Assert.True(didCreateCrop);
+        Assert.Equal(15, cropRect.X);
+        Assert.Equal(22, cropRect.Y);
+        Assert.Equal(30, cropRect.Width);
+        Assert.Equal(38, cropRect.Height);
+    }
+
+    private static Rect TransformRect(Rect rect, Matrix matrix)
+    {
+        Point[] points =
+        [
+            matrix.Transform(rect.TopLeft),
+            matrix.Transform(new Point(rect.Right, rect.Top)),
+            matrix.Transform(new Point(rect.Left, rect.Bottom)),
+            matrix.Transform(rect.BottomRight)
+        ];
+
+        double left = points.Min(static point => point.X);
+        double top = points.Min(static point => point.Y);
+        double right = points.Max(static point => point.X);
+        double bottom = points.Max(static point => point.Y);
+
+        return new Rect(new Point(left, top), new Point(right, bottom));
+    }
+}
diff --git a/Tests/GrabTemplateExecutorTests.cs b/Tests/GrabTemplateExecutorTests.cs
new file mode 100644
index 00000000..18f17917
--- /dev/null
+++ b/Tests/GrabTemplateExecutorTests.cs
@@ -0,0 +1,475 @@
+using Text_Grab.Models;
+using Text_Grab.Utilities;
+
+namespace Tests;
+
+public class GrabTemplateExecutorTests
+{
+    // ── ApplyOutputTemplate – basic substitution ──────────────────────────────
+
+    [Fact]
+    public void ApplyOutputTemplate_SingleRegion_SubstitutesCorrectly()
+    {
+        Dictionary<int, string> regions = new() { [1] = "Alice" };
+        string result = GrabTemplateExecutor.ApplyOutputTemplate("Name: {1}", regions);
+        Assert.Equal("Name: Alice", result);
+    }
+
+    [Fact]
+    public void ApplyOutputTemplate_MultipleRegions_SubstitutesAll()
+    {
+        Dictionary<int, string> regions = new()
+        {
+            [1] = "Alice",
+            [2] = "alice@example.com"
+        };
+        string result = GrabTemplateExecutor.ApplyOutputTemplate("{1} <{2}>", regions);
+        Assert.Equal("Alice <alice@example.com>", result);
+    }
+
+    [Fact]
+    public void ApplyOutputTemplate_MissingRegion_ReplacesWithEmpty()
+    {
+        Dictionary<int, string> regions = new() { [1] = "Alice" };
+        // Region 2 not present
+        string result = GrabTemplateExecutor.ApplyOutputTemplate("{1} {2}", regions);
+        Assert.Equal("Alice ", result);
+    }
+
+    [Fact]
+    public void ApplyOutputTemplate_EmptyTemplate_ReturnsEmpty()
+    {
+        Dictionary<int, string> regions = new() { [1] = "value" };
+        string result = GrabTemplateExecutor.ApplyOutputTemplate(string.Empty, regions);
+        Assert.Equal(string.Empty, result);
+    }
+
+    // ── Modifiers ──────────────────────────────────────────────────────────────
+
+    [Fact]
+    public void ApplyOutputTemplate_TrimModifier_TrimsWhitespace()
+    {
+        Dictionary<int, string> regions = new() { [1] = "  hello  " };
+        string result = GrabTemplateExecutor.ApplyOutputTemplate("{1:trim}", regions);
+        Assert.Equal("hello", result);
+    }
+
+    [Fact]
+    public void ApplyOutputTemplate_UpperModifier_ConvertsToUpper()
+    {
+        Dictionary<int, string> regions = new() { [1] = "hello" };
+        string result = GrabTemplateExecutor.ApplyOutputTemplate("{1:upper}", regions);
+        Assert.Equal("HELLO", result);
+    }
+
+    [Fact]
+    public void ApplyOutputTemplate_LowerModifier_ConvertsToLower()
+    {
+        Dictionary<int, string> regions = new() { [1] = "HELLO" };
+        string result = GrabTemplateExecutor.ApplyOutputTemplate("{1:lower}", regions);
+        Assert.Equal("hello", result);
+    }
+
+    [Fact]
+    public void ApplyOutputTemplate_UnknownModifier_LeavesTextAsIs()
+    {
+        Dictionary<int, string> regions = new() { [1] = "hello" };
+        string result = GrabTemplateExecutor.ApplyOutputTemplate("{1:unknown}", regions);
+        Assert.Equal("hello", result);
+    }
+
+    // ── Escape sequences ──────────────────────────────────────────────────────
+
+    [Fact]
+    public void ApplyOutputTemplate_NewlineEscape_InsertsNewline()
+    {
+        Dictionary<int, string> regions = new() { [1] = "A", [2] = "B" };
+        string result = GrabTemplateExecutor.ApplyOutputTemplate("{1}\\n{2}", regions);
+        Assert.Equal("A\nB", result);
+    }
+
+    [Fact]
+    public void ApplyOutputTemplate_TabEscape_InsertsTab()
+    {
+        Dictionary<int, string> regions = new() { [1] = "A", [2] = "B" };
+        string result = GrabTemplateExecutor.ApplyOutputTemplate("{1}\\t{2}", regions);
+        Assert.Equal("A\tB", result);
+    }
+
+    [Fact]
+    public void ApplyOutputTemplate_LiteralBraceEscape_PreservesBrace()
+    {
+        Dictionary<int, string> regions = new() { [1] = "value" };
+        // \{ in template produces literal {, then {1} → value, then literal text }
+        string result = GrabTemplateExecutor.ApplyOutputTemplate("\\{{1}}", regions);
+        Assert.Equal("{value}", result);
+    }
+
+    [Fact]
+    public void ApplyOutputTemplate_DoubleBackslash_PreservesBackslash()
+    {
+        Dictionary<int, string> regions = new() { [1] = "A" };
+        string result = GrabTemplateExecutor.ApplyOutputTemplate("{1}\\\\{1}", regions);
+        Assert.Equal(@"A\A", result);
+    }
+
+    // ── ValidateOutputTemplate ────────────────────────────────────────────────
+
+    [Fact]
+    public void ValidateOutputTemplate_ValidTemplate_ReturnsNoIssues()
+    {
+        List<string> issues = GrabTemplateExecutor.ValidateOutputTemplate("{1} {2}", [1, 2]);
+        Assert.Empty(issues);
+    }
+
+    [Fact]
+    public void ValidateOutputTemplate_OutOfRangeRegion_ReturnsIssue()
+    {
+        List<string> issues = GrabTemplateExecutor.ValidateOutputTemplate("{3}", [1, 2]);
+        Assert.NotEmpty(issues);
+        Assert.Contains(issues, i => i.Contains('3'));
+    }
+
+    [Fact]
+    public void ValidateOutputTemplate_EmptyTemplate_ReturnsIssue()
+    {
+        List<string> issues = GrabTemplateExecutor.ValidateOutputTemplate(string.Empty, [1]);
+        Assert.NotEmpty(issues);
+    }
+
+    [Fact]
+    public void ValidateOutputTemplate_NoRegionsReferenced_ReturnsIssue()
+    {
+        // Template has no {N} references
+        List<string> issues = GrabTemplateExecutor.ValidateOutputTemplate("static text", [1, 2]);
+        Assert.NotEmpty(issues);
+    }
+
+    // ── Pattern placeholder – ApplyPatternPlaceholders ────────────────────────
+
+    [Fact]
+    public void ApplyPatternPlaceholders_FirstMatch_ReturnsFirstOccurrence()
+    {
+        string fullText = "Contact: alice@test.com and bob@test.com";
+        List<TemplatePatternMatch> patterns =
+        [
+            new("id1", "Email", "first")
+        ];
+        Dictionary<string, string> regexes = new()
+        {
+            ["id1"] = @"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}",
+            ["Email"] = @"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"
+        };
+
+        string result = GrabTemplateExecutor.ApplyPatternPlaceholders(
+            "Email: {p:Email:first}", fullText, patterns, regexes);
+
+        Assert.Equal("Email: alice@test.com", result);
+    }
+
+    [Fact]
+    public void ApplyPatternPlaceholders_LastMatch_ReturnsLastOccurrence()
+    {
+        string fullText = "Contact: alice@test.com and bob@test.com";
+        List<TemplatePatternMatch> patterns =
+        [
+            new("id1", "Email", "last")
+        ];
+        Dictionary<string, string> regexes = new()
+        {
+            ["id1"] = @"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}",
+            ["Email"] = @"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"
+        };
+
+        string result = GrabTemplateExecutor.ApplyPatternPlaceholders(
+            "Email: {p:Email:last}", fullText, patterns, regexes);
+
+        Assert.Equal("Email: bob@test.com", result);
+    }
+
+    [Fact]
+    public void ApplyPatternPlaceholders_AllMatches_JoinsWithDefaultSeparator()
+    {
+        string fullText = "Contact: alice@test.com and bob@test.com";
+        List<TemplatePatternMatch> patterns =
+        [
+            new("id1", "Email", "all", ", ")
+        ];
+        Dictionary<string, string> regexes = new()
+        {
+            ["id1"] = @"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}",
+            ["Email"] = @"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"
+        };
+
+        string result = GrabTemplateExecutor.ApplyPatternPlaceholders(
+            "Emails: {p:Email:all}", fullText, patterns, regexes);
+
+        Assert.Equal("Emails: alice@test.com, bob@test.com", result);
+    }
+
+    [Fact]
+    public void ApplyPatternPlaceholders_AllMatchesCustomSeparator_UsesOverride()
+    {
+        string fullText = "Contact: alice@test.com and bob@test.com";
+        List<TemplatePatternMatch> patterns =
+        [
+            new("id1", "Email", "all", ", ")
+        ];
+        Dictionary<string, string> regexes = new()
+        {
+            ["id1"] = @"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}",
+            ["Email"] = @"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"
+        };
+
+        string result = GrabTemplateExecutor.ApplyPatternPlaceholders(
+            "Emails: {p:Email:all: | }", fullText, patterns, regexes);
+
+        Assert.Equal("Emails: alice@test.com | bob@test.com", result);
+    }
+
+    [Fact]
+    public void ApplyPatternPlaceholders_NthMatch_ReturnsSingleIndex()
+    {
+        string fullText = "Numbers: 100 200 300";
+        List<TemplatePatternMatch> patterns =
+        [
+            new("id1", "Integer", "2")
+        ];
+        Dictionary<string, string> regexes = new()
+        {
+            ["id1"] = @"\d+",
+            ["Integer"] = @"\d+"
+        };
+
+        string result = GrabTemplateExecutor.ApplyPatternPlaceholders(
+            "Second: {p:Integer:2}", fullText, patterns, regexes);
+
+        Assert.Equal("Second: 200", result);
+    }
+
+    [Fact]
+    public void ApplyPatternPlaceholders_MultipleIndices_JoinsSelected()
+    {
+        string fullText = "Numbers: 100 200 300 400";
+        List<TemplatePatternMatch> patterns =
+        [
+            new("id1", "Integer", "1,3", "; ")
+        ];
+        Dictionary<string, string> regexes = new()
+        {
+            ["id1"] = @"\d+",
+            ["Integer"] = @"\d+"
+        };
+
+        string result = GrabTemplateExecutor.ApplyPatternPlaceholders(
+            "Selected: {p:Integer:1,3}", fullText, patterns, regexes);
+
+        Assert.Equal("Selected: 100; 300", result);
+    }
+
+    [Fact]
+    public void ApplyPatternPlaceholders_NoMatches_ReturnsEmpty()
+    {
+        string fullText = "No emails here";
+        List<TemplatePatternMatch> patterns =
+        [
+            new("id1", "Email", "first")
+        ];
+        Dictionary<string, string> regexes = new()
+        {
+            ["id1"] = @"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}",
+            ["Email"] = @"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"
+        };
+
+        string result = GrabTemplateExecutor.ApplyPatternPlaceholders(
+            "Email: {p:Email:first}", fullText, patterns, regexes);
+
+        Assert.Equal("Email: ", result);
+    }
+
+    [Fact]
+    public void ApplyPatternPlaceholders_PatternNotFound_ReturnsEmpty()
+    {
+        string fullText = "Some text";
+        List<TemplatePatternMatch> patterns =
+        [
+            new("id1", "Email", "first")
+        ];
+        // No regexes provided for this pattern
+        Dictionary<string, string> regexes = [];
+
+        string result = GrabTemplateExecutor.ApplyPatternPlaceholders(
+            "Email: {p:Email:first}", fullText, patterns, regexes);
+
+        Assert.Equal("Email: ", result);
+    }
+
+    [Fact]
+    public void ApplyPatternPlaceholders_UnknownPatternName_LeavesPlaceholder()
+    {
+        string fullText = "Some text";
+        List<TemplatePatternMatch> patterns = []; // no patterns registered
+        Dictionary<string, string> regexes = [];
+
+        string result = GrabTemplateExecutor.ApplyPatternPlaceholders(
+            "Data: {p:Unknown:first}", fullText, patterns, regexes);
+
+        Assert.Equal("Data: {p:Unknown:first}", result);
+    }
+
+    [Fact]
+    public void ApplyPatternPlaceholders_IndexOutOfRange_ReturnsEmpty()
+    {
+        string fullText = "One: 100";
+        List<TemplatePatternMatch> patterns =
+        [
+            new("id1", "Integer", "5") // only 1 match, requesting 5th
+        ];
+        Dictionary<string, string> regexes = new()
+        {
+            ["id1"] = @"\d+",
+            ["Integer"] = @"\d+"
+        };
+
+        string result = GrabTemplateExecutor.ApplyPatternPlaceholders(
+            "Fifth: {p:Integer:5}", fullText, patterns, regexes);
+
+        Assert.Equal("Fifth: ", result);
+    }
+
+    // ── ExtractMatchesByMode ──────────────────────────────────────────────────
+
+    [Fact]
+    public void ExtractMatchesByMode_First_ReturnsFirst()
+    {
+        System.Text.RegularExpressions.MatchCollection matches =
+            System.Text.RegularExpressions.Regex.Matches("abc def ghi", @"\w+");
+
+        string result = GrabTemplateExecutor.ExtractMatchesByMode(matches, "first", ", ");
+        Assert.Equal("abc", result);
+    }
+
+    [Fact]
+    public void ExtractMatchesByMode_Last_ReturnsLast()
+    {
+        System.Text.RegularExpressions.MatchCollection matches =
+            System.Text.RegularExpressions.Regex.Matches("abc def ghi", @"\w+");
+
+        string result = GrabTemplateExecutor.ExtractMatchesByMode(matches, "last", ", ");
+        Assert.Equal("ghi", result);
+    }
+
+    [Fact]
+    public void ExtractMatchesByMode_All_JoinsAll()
+    {
+        System.Text.RegularExpressions.MatchCollection matches =
+            System.Text.RegularExpressions.Regex.Matches("abc def ghi", @"\w+");
+
+        string result = GrabTemplateExecutor.ExtractMatchesByMode(matches, "all", " | ");
+        Assert.Equal("abc | def | ghi", result);
+    }
+
+    // ── Hybrid template (regions + patterns) ──────────────────────────────────
+
+    [Fact]
+    public void HybridTemplate_RegionsAndPatterns_BothResolved()
+    {
+        // First apply regions
+        Dictionary<int, string> regions = new() { [1] = "John Doe" };
+        string template = "Name: {1}\\nEmail: {p:Email:first}";
+        string afterRegions = GrabTemplateExecutor.ApplyOutputTemplate(template, regions);
+
+        // Then apply patterns
+        string fullText = "Contact john@example.com for details";
+        List<TemplatePatternMatch> patterns =
+        [
+            new("id1", "Email", "first")
+        ];
+        Dictionary<string, string> regexes = new()
+        {
+            ["id1"] = @"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}",
+            ["Email"] = @"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"
+        };
+
+        string result = GrabTemplateExecutor.ApplyPatternPlaceholders(
+            afterRegions, fullText, patterns, regexes);
+
+        Assert.Equal("Name: John Doe\nEmail: john@example.com", result);
+    }
+
+    // ── GrabTemplate model ────────────────────────────────────────────────────
+
+    [Fact]
+    public void GrabTemplate_IsValid_PatternOnlyTemplate()
+    {
+        GrabTemplate template = new("Test")
+        {
+            OutputTemplate = "{p:Email:first}",
+            PatternMatches = [new("id1", "Email", "first")]
+        };
+
+        Assert.True(template.IsValid);
+    }
+
+    [Fact]
+    public void GrabTemplate_IsValid_RequiresNameAndOutput()
+    {
+        GrabTemplate template = new()
+        {
+            PatternMatches = [new("id1", "Email", "first")]
+        };
+
+        Assert.False(template.IsValid);
+    }
+
+    [Fact]
+    public void GrabTemplate_GetReferencedPatternNames_ParsesNames()
+    {
+        GrabTemplate template = new("Test")
+        {
+            OutputTemplate = "Email: {p:Email Address:first}\\nPhone: {p:Phone Number:all:, }"
+        };
+
+        List<string> names = [.. template.GetReferencedPatternNames()];
+        Assert.Equal(2, names.Count);
+        Assert.Contains("Email Address", names);
+        Assert.Contains("Phone Number", names);
+    }
+
+    // ── ValidateOutputTemplate with patterns ──────────────────────────────────
+
+    [Fact]
+    public void ValidateOutputTemplate_ValidPatternPlaceholder_NoIssues()
+    {
+        List<string> issues = GrabTemplateExecutor.ValidateOutputTemplate(
+            "{p:Email:first}",
+            [],
+            ["Email"]);
+
+        Assert.Empty(issues);
+    }
+
+    [Fact]
+    public void ValidateOutputTemplate_UnknownPatternName_ReturnsIssue()
+    {
+        List<string> issues = GrabTemplateExecutor.ValidateOutputTemplate(
+            "{p:Unknown Pattern:first}",
+            [],
+            ["Email"]);
+
+        Assert.NotEmpty(issues);
+        Assert.Contains(issues, i => i.Contains("Unknown Pattern"));
+    }
+
+    [Fact]
+    public void ValidateOutputTemplate_InvalidMatchMode_ReturnsIssue()
+    {
+        List<string> issues = GrabTemplateExecutor.ValidateOutputTemplate(
+            "{p:Email:invalid_mode}",
+            [],
+            ["Email"]);
+
+        Assert.NotEmpty(issues);
+        Assert.Contains(issues, i => i.Contains("invalid_mode"));
+    }
+}
diff --git a/Tests/GrabTemplateManagerTests.cs b/Tests/GrabTemplateManagerTests.cs
new file mode 100644
index 00000000..c4d93e36
--- /dev/null
+++ b/Tests/GrabTemplateManagerTests.cs
@@ -0,0 +1,228 @@
+using System.IO;
+using Text_Grab.Models;
+using Text_Grab.Utilities;
+
+namespace Tests;
+
+public class GrabTemplateManagerTests : IDisposable
+{
+    // Use a temp file so tests don't pollute each other or real user data
+    private readonly string _tempFilePath;
+
+    public GrabTemplateManagerTests()
+    {
+        _tempFilePath = Path.Combine(Path.GetTempPath(), $"GrabTemplates_Test_{Guid.NewGuid()}.json");
+        GrabTemplateManager.TestFilePath = _tempFilePath;
+    }
+
+    public void Dispose()
+    {
+        GrabTemplateManager.TestFilePath = null;
+        if (File.Exists(_tempFilePath))
+            File.Delete(_tempFilePath);
+    }
+
+    // ── GetAllTemplates ───────────────────────────────────────────────────────
+
+    [Fact]
+    public void GetAllTemplates_WhenEmpty_ReturnsEmptyList()
+    {
+        List<GrabTemplate> templates = GrabTemplateManager.GetAllTemplates();
+        Assert.Empty(templates);
+    }
+
+    [Fact]
+    public void GetAllTemplates_AfterAddingTemplate_ReturnsSavedTemplate()
+    {
+        GrabTemplate template = CreateSampleTemplate("Invoice");
+        GrabTemplateManager.AddOrUpdateTemplate(template);
+
+        List<GrabTemplate> templates = GrabTemplateManager.GetAllTemplates();
+        Assert.Single(templates);
+        Assert.Equal("Invoice", templates[0].Name);
+    }
+
+    // ── GetTemplateById ───────────────────────────────────────────────────────
+
+    [Fact]
+    public void GetTemplateById_ExistingId_ReturnsTemplate()
+    {
+        GrabTemplate template = CreateSampleTemplate("Business Card");
+        GrabTemplateManager.AddOrUpdateTemplate(template);
+
+        GrabTemplate? found = GrabTemplateManager.GetTemplateById(template.Id);
+
+        Assert.NotNull(found);
+        Assert.Equal(template.Id, found.Id);
+        Assert.Equal("Business Card", found.Name);
+    }
+
+    [Fact]
+    public void GetTemplateById_NonExistentId_ReturnsNull()
+    {
+        GrabTemplate? found = GrabTemplateManager.GetTemplateById("non-existent-id");
+        Assert.Null(found);
+    }
+
+    // ── AddOrUpdateTemplate ───────────────────────────────────────────────────
+
+    [Fact]
+    public void AddOrUpdateTemplate_AddNew_IncrementsCount()
+    {
+        GrabTemplateManager.AddOrUpdateTemplate(CreateSampleTemplate("T1"));
+        GrabTemplateManager.AddOrUpdateTemplate(CreateSampleTemplate("T2"));
+
+        List<GrabTemplate> templates = GrabTemplateManager.GetAllTemplates();
+        Assert.Equal(2, templates.Count);
+    }
+
+    [Fact]
+    public void AddOrUpdateTemplate_UpdateExisting_ReplacesByIdNotDuplicate()
+    {
+        GrabTemplate original = CreateSampleTemplate("Original Name");
+        GrabTemplateManager.AddOrUpdateTemplate(original);
+
+        original.Name = "Updated Name";
+        GrabTemplateManager.AddOrUpdateTemplate(original);
+
+        List<GrabTemplate> templates = GrabTemplateManager.GetAllTemplates();
+        Assert.Single(templates);
+        Assert.Equal("Updated Name", templates[0].Name);
+    }
+
+    // ── DeleteTemplate ────────────────────────────────────────────────────────
+
+    [Fact]
+    public void DeleteTemplate_ExistingId_RemovesTemplate()
+    {
+        GrabTemplate template = CreateSampleTemplate("ToDelete");
+        GrabTemplateManager.AddOrUpdateTemplate(template);
+
+        GrabTemplateManager.DeleteTemplate(template.Id);
+
+        List<GrabTemplate> templates = GrabTemplateManager.GetAllTemplates();
+        Assert.Empty(templates);
+    }
+
+    [Fact]
+    public void DeleteTemplate_NonExistentId_DoesNotThrow()
+    {
+        GrabTemplateManager.AddOrUpdateTemplate(CreateSampleTemplate("Keeper"));
+        GrabTemplateManager.DeleteTemplate("does-not-exist");
+
+        // Should still have the original template
+        Assert.Single(GrabTemplateManager.GetAllTemplates());
+    }
+
+    // ── DuplicateTemplate ─────────────────────────────────────────────────────
+
+    [Fact]
+    public void DuplicateTemplate_ValidId_CreatesNewTemplateWithCopyPrefix()
+    {
+        GrabTemplate original = CreateSampleTemplate("My Template");
+        GrabTemplateManager.AddOrUpdateTemplate(original);
+
+        GrabTemplate? copy = GrabTemplateManager.DuplicateTemplate(original.Id);
+
+        Assert.NotNull(copy);
+        Assert.NotEqual(original.Id, copy.Id);
+        Assert.Contains("(copy)", copy.Name);
+        Assert.Equal(2, GrabTemplateManager.GetAllTemplates().Count);
+    }
+
+    [Fact]
+    public void DuplicateTemplate_NonExistentId_ReturnsNull()
+    {
+        GrabTemplate? copy = GrabTemplateManager.DuplicateTemplate("not-there");
+        Assert.Null(copy);
+    }
+
+    // ── CreateButtonInfoForTemplate ───────────────────────────────────────────
+
+    [Fact]
+    public void CreateButtonInfoForTemplate_SetsTemplateId()
+    {
+        GrabTemplate template = CreateSampleTemplate("Card");
+
+        Text_Grab.Models.ButtonInfo button = GrabTemplateManager.CreateButtonInfoForTemplate(template);
+
+        Assert.Equal(template.Id, button.TemplateId);
+        Assert.Equal("ApplyTemplate_Click", button.ClickEvent);
+        Assert.Equal(template.Name, button.ButtonText);
+    }
+
+    // ── Corrupt JSON robustness ───────────────────────────────────────────────
+
+    [Fact]
+    public void GetAllTemplates_CorruptJson_ReturnsEmptyList()
+    {
+        File.WriteAllText(_tempFilePath, "{ this is not valid json }}}");
+
+        List<GrabTemplate> templates = GrabTemplateManager.GetAllTemplates();
+        Assert.Empty(templates);
+    }
+
+    // ── GrabTemplate model ────────────────────────────────────────────────────
+
+    [Fact]
+    public void GrabTemplate_IsValid_TrueWhenNameRegionsAndOutputTemplateSet()
+    {
+        GrabTemplate template = CreateSampleTemplate("Valid");
+        Assert.True(template.IsValid);
+    }
+
+    [Fact]
+    public void GrabTemplate_IsValid_FalseWhenNameEmpty()
+    {
+        GrabTemplate template = CreateSampleTemplate(string.Empty);
+        Assert.False(template.IsValid);
+    }
+
+    [Fact]
+    public void GrabTemplate_IsValid_FalseWhenNoRegions()
+    {
+        GrabTemplate template = CreateSampleTemplate("No Regions");
+        template.Regions.Clear();
+        Assert.False(template.IsValid);
+    }
+
+    [Fact]
+    public void GrabTemplate_GetReferencedRegionNumbers_ParsesPlaceholders()
+    {
+        GrabTemplate template = CreateSampleTemplate("Multi");
+        template.OutputTemplate = "{1} {2} {1:upper}";
+
+        HashSet<int> referenced = template.GetReferencedRegionNumbers().ToHashSet();
+
+        Assert.Contains(1, referenced);
+        Assert.Contains(2, referenced);
+        Assert.Equal(2, referenced.Count);
+    }
+
+    // ── Helper ────────────────────────────────────────────────────────────────
+
+    private static GrabTemplate CreateSampleTemplate(string name)
+    {
+        return new GrabTemplate
+        {
+            Id = Guid.NewGuid().ToString(),
+            Name = name,
+            Description = "Test template",
+            OutputTemplate = "{1}",
+            ReferenceImageWidth = 800,
+            ReferenceImageHeight = 600,
+            Regions =
+            [
+                new Text_Grab.Models.TemplateRegion
+                {
+                    RegionNumber = 1,
+                    Label = "Field 1",
+                    RatioLeft = 0.1,
+                    RatioTop = 0.1,
+                    RatioWidth = 0.5,
+                    RatioHeight = 0.1,
+                }
+            ]
+        };
+    }
+}
diff --git a/Tests/Tests.csproj b/Tests/Tests.csproj
index f436f3b2..eb6c0bf8 100644
--- a/Tests/Tests.csproj
+++ b/Tests/Tests.csproj
@@ -13,13 +13,13 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="coverlet.collector" Version="6.0.4">
+        <PackageReference Include="coverlet.collector" Version="8.0.0">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.3.0" />
         <PackageReference Include="Moq" Version="4.20.72" />
-        <PackageReference Include="NCalcAsync" Version="5.11.0" />
+        <PackageReference Include="NCalcAsync" Version="5.12.0" />
         <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
             <PrivateAssets>all</PrivateAssets>
diff --git a/Tests/WindowSelectionUtilitiesTests.cs b/Tests/WindowSelectionUtilitiesTests.cs
new file mode 100644
index 00000000..7eefcff3
--- /dev/null
+++ b/Tests/WindowSelectionUtilitiesTests.cs
@@ -0,0 +1,33 @@
+using System.Windows;
+using Text_Grab.Models;
+using Text_Grab.Utilities;
+
+namespace Tests;
+
+public class WindowSelectionUtilitiesTests
+{
+    [Fact]
+    public void FindWindowAtPoint_ReturnsFirstMatchingCandidate()
+    {
+        WindowSelectionCandidate topCandidate = new((nint)1, new Rect(0, 0, 40, 40), "Top", 100);
+        WindowSelectionCandidate lowerCandidate = new((nint)2, new Rect(0, 0, 60, 60), "Lower", 101);
+
+        WindowSelectionCandidate? found = WindowSelectionUtilities.FindWindowAtPoint(
+            [topCandidate, lowerCandidate],
+            new Point(20, 20));
+
+        Assert.Same(topCandidate, found);
+    }
+
+    [Fact]
+    public void FindWindowAtPoint_ReturnsNullWhenPointIsOutsideEveryCandidate()
+    {
+        WindowSelectionCandidate candidate = new((nint)1, new Rect(0, 0, 40, 40), "Only", 100);
+
+        WindowSelectionCandidate? found = WindowSelectionUtilities.FindWindowAtPoint(
+            [candidate],
+            new Point(80, 80));
+
+        Assert.Null(found);
+    }
+}
diff --git a/Text-Grab/App.config b/Text-Grab/App.config
index ab9b17f7..4675d28e 100644
--- a/Text-Grab/App.config
+++ b/Text-Grab/App.config
@@ -211,6 +211,15 @@
             <setting name="PostGrabStayOpen" serializeAs="String">
                 <value>False</value>
             </setting>
+            <setting name="GrabTemplatesJSON" serializeAs="String">
+                <value />
+            </setting>
+            <setting name="AddToContextMenu" serializeAs="String">
+                <value>False</value>
+            </setting>
+            <setting name="RegisterOpenWith" serializeAs="String">
+                <value>False</value>
+            </setting>
         </Text_Grab.Properties.Settings>
     </userSettings>
 </configuration>
\ No newline at end of file
diff --git a/Text-Grab/App.xaml b/Text-Grab/App.xaml
index 9cd6c706..2f2e0bd6 100644
--- a/Text-Grab/App.xaml
+++ b/Text-Grab/App.xaml
@@ -40,6 +40,7 @@
                 </ResourceDictionary>
                 <ui:ThemesDictionary Theme="Dark" />
                 <ui:ControlsDictionary />
+                <ResourceDictionary Source="/Styles/ListViewScrollFix.xaml" />
                 <ResourceDictionary Source="/Styles/Colors.xaml" />
                 <ResourceDictionary Source="/Styles/TextStyles.xaml" />
                 <ResourceDictionary Source="/Styles/ButtonStyles.xaml" />
diff --git a/Text-Grab/Controls/InlineChipElement.cs b/Text-Grab/Controls/InlineChipElement.cs
new file mode 100644
index 00000000..beab9d6b
--- /dev/null
+++ b/Text-Grab/Controls/InlineChipElement.cs
@@ -0,0 +1,58 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+
+namespace Text_Grab.Controls;
+
+[TemplatePart(Name = PartRemoveButton, Type = typeof(Button))]
+public class InlineChipElement : Control
+{
+    private const string PartRemoveButton = "PART_RemoveButton";
+
+    public static readonly DependencyProperty DisplayNameProperty =
+        DependencyProperty.Register(nameof(DisplayName), typeof(string), typeof(InlineChipElement),
+            new PropertyMetadata(string.Empty));
+
+    public static readonly DependencyProperty ValueProperty =
+        DependencyProperty.Register(nameof(Value), typeof(string), typeof(InlineChipElement),
+            new PropertyMetadata(string.Empty));
+
+    public string DisplayName
+    {
+        get => (string)GetValue(DisplayNameProperty);
+        set => SetValue(DisplayNameProperty, value);
+    }
+
+    public string Value
+    {
+        get => (string)GetValue(ValueProperty);
+        set => SetValue(ValueProperty, value);
+    }
+
+    public event EventHandler? RemoveRequested;
+
+    private Button? _removeButton;
+
+    static InlineChipElement()
+    {
+        DefaultStyleKeyProperty.OverrideMetadata(
+            typeof(InlineChipElement),
+            new FrameworkPropertyMetadata(typeof(InlineChipElement)));
+    }
+
+    public override void OnApplyTemplate()
+    {
+        base.OnApplyTemplate();
+
+        if (_removeButton is not null)
+            _removeButton.Click -= RemoveButton_Click;
+
+        _removeButton = GetTemplateChild(PartRemoveButton) as Button;
+
+        if (_removeButton is not null)
+            _removeButton.Click += RemoveButton_Click;
+    }
+
+    private void RemoveButton_Click(object sender, RoutedEventArgs e)
+        => RemoveRequested?.Invoke(this, EventArgs.Empty);
+}
diff --git a/Text-Grab/Controls/InlinePickerItem.cs b/Text-Grab/Controls/InlinePickerItem.cs
new file mode 100644
index 00000000..da922a71
--- /dev/null
+++ b/Text-Grab/Controls/InlinePickerItem.cs
@@ -0,0 +1,24 @@
+namespace Text_Grab.Controls;
+
+public class InlinePickerItem
+{
+    public string DisplayName { get; set; } = string.Empty;
+    public string Value { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Optional group label used to render section headers in the picker popup
+    /// (e.g. "Regions", "Patterns").
+    /// </summary>
+    public string Group { get; set; } = string.Empty;
+
+    public InlinePickerItem() { }
+
+    public InlinePickerItem(string displayName, string value, string group = "")
+    {
+        DisplayName = displayName;
+        Value = value;
+        Group = group;
+    }
+
+    public override string ToString() => DisplayName;
+}
diff --git a/Text-Grab/Controls/InlinePickerRichTextBox.cs b/Text-Grab/Controls/InlinePickerRichTextBox.cs
new file mode 100644
index 00000000..0957745d
--- /dev/null
+++ b/Text-Grab/Controls/InlinePickerRichTextBox.cs
@@ -0,0 +1,730 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Effects;
+using Text_Grab.Models;
+
+namespace Text_Grab.Controls;
+
+/// <summary>
+/// A RichTextBox that shows a compact inline picker popup when the trigger character
+/// (default '{') is typed, allowing users to insert named value chips into the document.
+/// Supports grouped items with section headers (e.g. "Regions" and "Patterns").
+/// </summary>
+public class InlinePickerRichTextBox : RichTextBox
+{
+    private readonly Popup _popup;
+    private readonly ListBox _listBox;
+
+    private TextPointer? _triggerStart;
+    private bool _isModifyingDocument;
+
+    #region Dependency Properties
+
+    public static readonly DependencyProperty ItemsSourceProperty =
+        DependencyProperty.Register(
+            nameof(ItemsSource),
+            typeof(IEnumerable<InlinePickerItem>),
+            typeof(InlinePickerRichTextBox),
+            new PropertyMetadata(null));
+
+    public static readonly DependencyProperty SerializedTextProperty =
+        DependencyProperty.Register(
+            nameof(SerializedText),
+            typeof(string),
+            typeof(InlinePickerRichTextBox),
+            new FrameworkPropertyMetadata(
+                string.Empty,
+                FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));
+
+    #endregion Dependency Properties
+
+    #region Properties
+
+    public IEnumerable<InlinePickerItem> ItemsSource
+    {
+        get => (IEnumerable<InlinePickerItem>?)GetValue(ItemsSourceProperty) ?? [];
+        set => SetValue(ItemsSourceProperty, value);
+    }
+
+    /// <summary>
+    /// The document serialized back to a plain string, where each chip is replaced
+    /// with its <see cref="InlinePickerItem.Value"/> (e.g. "{1}").
+    /// Supports two-way binding.
+    /// </summary>
+    public string SerializedText
+    {
+        get => (string)GetValue(SerializedTextProperty);
+        set => SetValue(SerializedTextProperty, value);
+    }
+
+    /// <summary>Character that opens the picker popup. Default is '{'.</summary>
+    public char TriggerChar { get; set; } = '{';
+
+    #endregion Properties
+
+    public event EventHandler<InlinePickerItem>? ItemInserted;
+
+    /// <summary>
+    /// Called when a pattern-group item is selected. The handler should show the
+    /// <see cref="PatternMatchModeDialog"/> and return the configured
+    /// <see cref="TemplatePatternMatch"/>, or null to cancel.
+    /// </summary>
+    public Func<InlinePickerItem, TemplatePatternMatch?>? PatternItemSelected { get; set; }
+
+    static InlinePickerRichTextBox()
+    {
+        DefaultStyleKeyProperty.OverrideMetadata(
+            typeof(InlinePickerRichTextBox),
+            new FrameworkPropertyMetadata(typeof(InlinePickerRichTextBox)));
+    }
+
+    public InlinePickerRichTextBox()
+    {
+        AcceptsReturn = false;
+        VerticalScrollBarVisibility = ScrollBarVisibility.Disabled;
+        HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
+
+        _listBox = BuildPopupListBox();
+
+        Border popupBorder = new()
+        {
+            Child = _listBox,
+            CornerRadius = new CornerRadius(8),
+            BorderThickness = new Thickness(1),
+            Padding = new Thickness(2),
+            Effect = new DropShadowEffect
+            {
+                BlurRadius = 6,
+                Direction = 270,
+                Opacity = 0.2,
+                ShadowDepth = 2,
+                Color = Colors.Black
+            }
+        };
+        popupBorder.SetResourceReference(BackgroundProperty, "SolidBackgroundFillColorBaseBrush");
+        popupBorder.SetResourceReference(BorderBrushProperty, "Teal");
+
+        _popup = new Popup
+        {
+            Child = popupBorder,
+            StaysOpen = true,
+            AllowsTransparency = true,
+            Placement = PlacementMode.RelativePoint,
+            PlacementTarget = this,
+        };
+
+        TextChanged += OnTextChanged;
+        PreviewKeyDown += OnPreviewKeyDown;
+        LostKeyboardFocus += OnLostKeyboardFocus;
+    }
+
+    private ListBox BuildPopupListBox()
+    {
+        ListBox lb = new()
+        {
+            MinWidth = 140,
+            MaxHeight = 200,
+            FontSize = 11,
+            BorderThickness = new Thickness(0),
+            Background = Brushes.Transparent,
+            FocusVisualStyle = null,
+            Focusable = false,
+        };
+        lb.SetResourceReference(ForegroundProperty, "TextFillColorPrimaryBrush");
+
+        // Use a template selector to render headers vs selectable items
+        lb.ItemTemplateSelector = new PickerItemTemplateSelector(
+            BuildSelectableItemTemplate(),
+            BuildHeaderItemTemplate());
+
+        lb.PreviewMouseDown += ListBox_PreviewMouseDown;
+        lb.ItemContainerStyle = BuildCompactItemStyle();
+        return lb;
+    }
+
+    private static DataTemplate BuildSelectableItemTemplate()
+    {
+        DataTemplate dt = new();
+        FrameworkElementFactory spFactory = new(typeof(StackPanel));
+        spFactory.SetValue(StackPanel.OrientationProperty, Orientation.Horizontal);
+
+        FrameworkElementFactory nameFactory = new(typeof(TextBlock));
+        nameFactory.SetBinding(TextBlock.TextProperty,
+            new System.Windows.Data.Binding(nameof(InlinePickerItem.DisplayName)));
+        nameFactory.SetValue(TextBlock.VerticalAlignmentProperty, VerticalAlignment.Center);
+        nameFactory.SetValue(FrameworkElement.MarginProperty, new Thickness(6, 2, 4, 2));
+
+        FrameworkElementFactory valueFactory = new(typeof(TextBlock));
+        valueFactory.SetBinding(TextBlock.TextProperty,
+            new System.Windows.Data.Binding(nameof(InlinePickerItem.Value)));
+        valueFactory.SetValue(TextBlock.VerticalAlignmentProperty, VerticalAlignment.Center);
+        valueFactory.SetValue(TextBlock.FontSizeProperty, 9.0);
+        valueFactory.SetValue(FrameworkElement.MarginProperty, new Thickness(0, 2, 6, 2));
+        valueFactory.SetValue(TextBlock.OpacityProperty, 0.55);
+
+        spFactory.AppendChild(nameFactory);
+        spFactory.AppendChild(valueFactory);
+        dt.VisualTree = spFactory;
+        return dt;
+    }
+
+    private static DataTemplate BuildHeaderItemTemplate()
+    {
+        DataTemplate dt = new();
+        FrameworkElementFactory tb = new(typeof(TextBlock));
+        tb.SetBinding(TextBlock.TextProperty,
+            new System.Windows.Data.Binding(nameof(InlinePickerItem.DisplayName)));
+        tb.SetValue(TextBlock.FontSizeProperty, 9.5);
+        tb.SetValue(TextBlock.FontWeightProperty, FontWeights.SemiBold);
+        tb.SetValue(TextBlock.OpacityProperty, 0.6);
+        tb.SetValue(FrameworkElement.MarginProperty, new Thickness(4, 4, 4, 2));
+        tb.SetValue(UIElement.IsHitTestVisibleProperty, false);
+        dt.VisualTree = tb;
+        return dt;
+    }
+
+    private static Style BuildCompactItemStyle()
+    {
+        // Provide a minimal ControlTemplate so WPF-UI's touch-sized ListBoxItem
+        // template (large MinHeight + padding) is completely replaced.
+        FrameworkElementFactory border = new(typeof(Border))
+        {
+            Name = "Bd"
+        };
+        border.SetValue(Border.BackgroundProperty, Brushes.Transparent);
+        border.SetValue(Border.CornerRadiusProperty, new CornerRadius(4));
+        border.SetValue(FrameworkElement.MarginProperty, new Thickness(1, 1, 1, 0));
+
+        FrameworkElementFactory cp = new(typeof(ContentPresenter));
+        cp.SetValue(FrameworkElement.VerticalAlignmentProperty, VerticalAlignment.Center);
+        border.AppendChild(cp);
+
+        ControlTemplate template = new(typeof(ListBoxItem)) { VisualTree = border };
+
+        Trigger hoverTrigger = new() { Property = UIElement.IsMouseOverProperty, Value = true };
+        hoverTrigger.Setters.Add(new Setter(Border.BackgroundProperty,
+            new SolidColorBrush(Color.FromArgb(0x22, 0x30, 0x8E, 0x98)), "Bd"));
+        template.Triggers.Add(hoverTrigger);
+
+        Trigger selectedTrigger = new() { Property = ListBoxItem.IsSelectedProperty, Value = true };
+        selectedTrigger.Setters.Add(new Setter(Border.BackgroundProperty,
+            new SolidColorBrush(Color.FromArgb(0x44, 0x30, 0x8E, 0x98)), "Bd"));
+        template.Triggers.Add(selectedTrigger);
+
+        Style style = new(typeof(ListBoxItem));
+        style.Setters.Add(new Setter(Control.TemplateProperty, template));
+        style.Setters.Add(new Setter(FrameworkElement.MinHeightProperty, 0.0));
+        style.Setters.Add(new Setter(Control.FocusVisualStyleProperty, (Style?)null));
+        return style;
+    }
+
+    #region Keyboard & Focus handling
+
+    private void OnLostKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
+    {
+        // Keep popup open if focus moved into it (e.g. scrollbar click)
+        if (e.NewFocus is DependencyObject target && IsVisualDescendant(_popup.Child, target))
+            return;
+
+        HidePopup();
+        _triggerStart = null;
+    }
+
+    protected override void OnPreviewMouseLeftButtonDown(MouseButtonEventArgs e)
+    {
+        // RichTextBox intercepts mouse-down for cursor placement before child controls receive it.
+        // Detect clicks on a chip's remove button and route them manually.
+        if (e.OriginalSource is DependencyObject source)
+        {
+            Button? btn = FindVisualAncestor<Button>(source);
+            if (btn != null && FindVisualAncestor<InlineChipElement>(btn) != null)
+            {
+                btn.RaiseEvent(new RoutedEventArgs(Button.ClickEvent, btn));
+                e.Handled = true;
+                return;
+            }
+        }
+        base.OnPreviewMouseLeftButtonDown(e);
+    }
+
+    private void OnPreviewKeyDown(object sender, KeyEventArgs e)
+    {
+        if (!_popup.IsOpen)
+            return;
+
+        switch (e.Key)
+        {
+            case Key.Down:
+                e.Handled = true;
+                MoveSelection(1);
+                break;
+
+            case Key.Up:
+                e.Handled = true;
+                MoveSelection(-1);
+                break;
+
+            case Key.Enter:
+            case Key.Tab:
+                e.Handled = true;
+                CommitSelection();
+                break;
+
+            case Key.Escape:
+                e.Handled = true;
+                HidePopup();
+                _triggerStart = null;
+                break;
+
+            case Key.Back:
+                // If backspace reaches the trigger char position, close the popup
+                TextPointer? oneBack = CaretPosition.GetNextInsertionPosition(LogicalDirection.Backward);
+                if (oneBack != null && _triggerStart != null && oneBack.CompareTo(_triggerStart) <= 0)
+                {
+                    HidePopup();
+                    _triggerStart = null;
+                }
+                break;
+        }
+    }
+
+    #endregion Keyboard & Focus handling
+
+    /// <summary>
+    /// Moves the listbox selection by <paramref name="direction"/> (+1 or -1),
+    /// skipping non-selectable section header items.
+    /// </summary>
+    private void MoveSelection(int direction)
+    {
+        int count = _listBox.Items.Count;
+        if (count == 0) return;
+
+        int start = _listBox.SelectedIndex;
+        int next = start;
+
+        for (int i = 0; i < count; i++)
+        {
+            next = (next + direction + count) % count;
+            if (_listBox.Items[next] is InlinePickerItem item && item.Group != HeaderGroupTag)
+            {
+                _listBox.SelectedIndex = next;
+                _listBox.ScrollIntoView(_listBox.SelectedItem);
+                return;
+            }
+        }
+    }
+
+    #region Text change & popup management
+
+    private void OnTextChanged(object sender, TextChangedEventArgs e)
+    {
+        if (_isModifyingDocument)
+            return;
+
+        if (_triggerStart == null)
+        {
+            // Detect trigger char just inserted before caret
+            TextPointer? prev = CaretPosition.GetNextInsertionPosition(LogicalDirection.Backward);
+            if (prev != null && new TextRange(prev, CaretPosition).Text == TriggerChar.ToString())
+            {
+                _triggerStart = prev;
+                RefreshPopup();
+                return;
+            }
+        }
+        else
+        {
+            // If caret moved back past the trigger, close the popup
+            if (CaretPosition.CompareTo(_triggerStart) <= 0)
+            {
+                HidePopup();
+                _triggerStart = null;
+                return;
+            }
+
+            RefreshPopup();
+        }
+
+        UpdateSerializedText();
+    }
+
+    private void RefreshPopup()
+    {
+        List<InlinePickerItem> filtered = GetFilteredItems();
+
+        if (filtered.Count == 0)
+        {
+            HidePopup();
+            return;
+        }
+
+        _listBox.ItemsSource = filtered;
+
+        // Auto-select the first non-header item
+        if (_listBox.SelectedIndex < 0 || _listBox.SelectedIndex >= filtered.Count)
+        {
+            int firstSelectable = filtered.FindIndex(i => i.Group != HeaderGroupTag);
+            _listBox.SelectedIndex = firstSelectable >= 0 ? firstSelectable : 0;
+        }
+
+        if (!_popup.IsOpen)
+        {
+            Rect caretRect = CaretPosition.GetCharacterRect(LogicalDirection.Forward);
+            _popup.HorizontalOffset = caretRect.X;
+            _popup.VerticalOffset = caretRect.Bottom + 2;
+            _popup.IsOpen = true;
+        }
+    }
+
+    private void HidePopup() => _popup.IsOpen = false;
+
+    private List<InlinePickerItem> GetFilteredItems()
+    {
+        if (_triggerStart == null)
+            return [];
+
+        string filterText = new TextRange(_triggerStart, CaretPosition).Text
+            .TrimStart(TriggerChar);
+
+        IEnumerable<InlinePickerItem> source = ItemsSource ?? [];
+
+        List<InlinePickerItem> filtered = filterText.Length == 0
+            ? [.. source]
+            : [.. source.Where(i =>
+                i.DisplayName.Contains(filterText, StringComparison.OrdinalIgnoreCase) ||
+                i.Value.Contains(filterText, StringComparison.OrdinalIgnoreCase))];
+
+        // Insert section headers when items have different groups
+        return InsertGroupHeaders(filtered);
+    }
+
+    private static List<InlinePickerItem> InsertGroupHeaders(List<InlinePickerItem> items)
+    {
+        if (items.Count == 0)
+            return items;
+
+        // Check if there are multiple distinct groups
+        List<string> distinctGroups = items
+            .Select(i => i.Group)
+            .Where(g => !string.IsNullOrEmpty(g))
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToList();
+
+        if (distinctGroups.Count <= 1)
+            return items;
+
+        // Build list with section headers
+        List<InlinePickerItem> result = [];
+        string? currentGroup = null;
+
+        foreach (InlinePickerItem item in items)
+        {
+            string group = string.IsNullOrEmpty(item.Group) ? "Other" : item.Group;
+            if (!string.Equals(group, currentGroup, StringComparison.OrdinalIgnoreCase))
+            {
+                currentGroup = group;
+                result.Add(new InlinePickerItem($"── {group} ──", "") { Group = HeaderGroupTag });
+            }
+            result.Add(item);
+        }
+
+        return result;
+    }
+
+    /// <summary>Sentinel group value for non-selectable section header items.</summary>
+    internal const string HeaderGroupTag = "__header__";
+
+    #endregion Text change & popup management
+
+    #region Selection & chip insertion
+
+    private void ListBox_PreviewMouseDown(object sender, MouseButtonEventArgs e)
+    {
+        DependencyObject? hit = e.OriginalSource as DependencyObject;
+        while (hit is not null and not ListBoxItem)
+            hit = VisualTreeHelper.GetParent(hit);
+
+        if (hit is ListBoxItem item)
+        {
+            _listBox.SelectedItem = item.DataContext ?? item.Content;
+            CommitSelection();
+            e.Handled = true;
+            Focus();
+        }
+    }
+
+    private void CommitSelection()
+    {
+        if (_listBox.SelectedItem is not InlinePickerItem selectedItem || _triggerStart == null)
+            return;
+
+        // Skip non-selectable header items
+        if (selectedItem.Group == HeaderGroupTag)
+            return;
+
+        // Save trigger position before any dialog opens (dialogs steal focus,
+        // which fires OnLostKeyboardFocus and nulls _triggerStart)
+        TextPointer savedTriggerStart = _triggerStart;
+
+        // For pattern items, invoke the dialog callback to configure match mode
+        bool isPatternItem = string.Equals(selectedItem.Group, "Patterns", StringComparison.OrdinalIgnoreCase);
+        InlinePickerItem itemToInsert = selectedItem;
+
+        if (isPatternItem && PatternItemSelected != null)
+        {
+            HidePopup();
+
+            TemplatePatternMatch? patternConfig = PatternItemSelected(selectedItem);
+            if (patternConfig == null)
+            {
+                _triggerStart = null;
+                return; // user cancelled
+            }
+
+            // Build the placeholder value from the dialog result
+            string placeholderValue = BuildPatternPlaceholder(patternConfig);
+            string displayLabel = $"{patternConfig.PatternName} ({patternConfig.MatchMode})";
+            itemToInsert = new InlinePickerItem(displayLabel, placeholderValue, selectedItem.Group);
+        }
+
+        _isModifyingDocument = true;
+        try
+        {
+            // Delete from trigger position to current caret (removes "{" + typed filter text)
+            new TextRange(savedTriggerStart, CaretPosition).Text = string.Empty;
+
+            // CaretPosition is now at the insertion point (where trigger was)
+            InlineChipElement chip = new()
+            {
+                DisplayName = itemToInsert.DisplayName,
+                Value = itemToInsert.Value,
+            };
+            chip.RemoveRequested += Chip_RemoveRequested;
+
+            InlineUIContainer container = new(chip, CaretPosition)
+            {
+                BaselineAlignment = BaselineAlignment.Center,
+            };
+
+            // Move caret to just after the inserted chip
+            TextPointer? afterChip = container.ElementEnd.GetNextInsertionPosition(LogicalDirection.Forward);
+            CaretPosition = afterChip ?? container.ElementEnd;
+
+            HidePopup();
+            _triggerStart = null;
+            ItemInserted?.Invoke(this, itemToInsert);
+        }
+        finally
+        {
+            _isModifyingDocument = false;
+        }
+
+        UpdateSerializedText();
+        Focus();
+    }
+
+    private static string BuildPatternPlaceholder(TemplatePatternMatch config)
+    {
+        string mode = config.MatchMode;
+
+        // Include separator in placeholder for "all" and multi-index modes
+        bool needsSeparator = mode == "all"
+            || (mode.Contains(',') && mode.Split(',').Length > 1);
+
+        if (needsSeparator && config.Separator != ", ")
+            return $"{{p:{config.PatternName}:{mode}:{config.Separator}}}";
+
+        return $"{{p:{config.PatternName}:{mode}}}";
+    }
+
+    private void Chip_RemoveRequested(object? sender, EventArgs e)
+    {
+        if (sender is not InlineChipElement chip)
+            return;
+
+        _isModifyingDocument = true;
+        try
+        {
+            foreach (Block block in Document.Blocks)
+            {
+                if (block is not Paragraph para)
+                    continue;
+
+                foreach (Inline inline in para.Inlines.ToList())
+                {
+                    if (inline is InlineUIContainer { Child: InlineChipElement c } iuc && c == chip)
+                    {
+                        para.Inlines.Remove(iuc);
+                        break;
+                    }
+                }
+            }
+        }
+        finally
+        {
+            _isModifyingDocument = false;
+        }
+
+        UpdateSerializedText();
+    }
+
+    #endregion Selection & chip insertion
+
+    #region Serialization
+
+    private void UpdateSerializedText() => SerializedText = GetSerializedText();
+
+    /// <summary>
+    /// Returns the document content as a plain string, with each chip replaced by
+    /// its <see cref="InlinePickerItem.Value"/> (e.g. "{1}").
+    /// </summary>
+    public string GetSerializedText()
+    {
+        StringBuilder sb = new();
+        bool firstPara = true;
+
+        foreach (Block block in Document.Blocks)
+        {
+            if (block is not Paragraph para)
+                continue;
+
+            if (!firstPara)
+                sb.AppendLine();
+            firstPara = false;
+
+            foreach (Inline inline in para.Inlines)
+            {
+                switch (inline)
+                {
+                    case Run run:
+                        sb.Append(run.Text);
+                        break;
+                    case InlineUIContainer { Child: InlineChipElement chip }:
+                        sb.Append(chip.Value);
+                        break;
+                }
+            }
+        }
+
+        return sb.ToString();
+    }
+
+    /// <summary>
+    /// Populates the document from a serialized string, recreating chips for any
+    /// <see cref="InlinePickerItem.Value"/> tokens found in <paramref name="text"/>.
+    /// </summary>
+    public void SetSerializedText(string text, IEnumerable<InlinePickerItem>? items = null)
+    {
+        _isModifyingDocument = true;
+        try
+        {
+            Document.Blocks.Clear();
+            Paragraph para = new();
+            Document.Blocks.Add(para);
+
+            IEnumerable<InlinePickerItem> source = items ?? ItemsSource ?? [];
+            string remaining = text ?? string.Empty;
+
+            while (remaining.Length > 0)
+            {
+                InlinePickerItem? nextItem = null;
+                int nextIndex = int.MaxValue;
+
+                foreach (InlinePickerItem item in source)
+                {
+                    int idx = remaining.IndexOf(item.Value, StringComparison.Ordinal);
+                    if (idx >= 0 && idx < nextIndex)
+                    {
+                        nextIndex = idx;
+                        nextItem = item;
+                    }
+                }
+
+                if (nextItem == null)
+                {
+                    para.Inlines.Add(new Run(remaining));
+                    break;
+                }
+
+                if (nextIndex > 0)
+                    para.Inlines.Add(new Run(remaining[..nextIndex]));
+
+                InlineChipElement chip = new()
+                {
+                    DisplayName = nextItem.DisplayName,
+                    Value = nextItem.Value,
+                };
+                chip.RemoveRequested += Chip_RemoveRequested;
+                para.Inlines.Add(new InlineUIContainer(chip) { BaselineAlignment = BaselineAlignment.Center });
+
+                remaining = remaining[(nextIndex + nextItem.Value.Length)..];
+            }
+        }
+        finally
+        {
+            _isModifyingDocument = false;
+        }
+
+        UpdateSerializedText();
+    }
+
+    #endregion Serialization
+
+    private static T? FindVisualAncestor<T>(DependencyObject element) where T : DependencyObject
+    {
+        DependencyObject? current = element;
+        while (current != null)
+        {
+            if (current is T match) return match;
+            // ContentElements (Paragraph, Run, Inline, …) are not Visual —
+            // VisualTreeHelper.GetParent throws for them, so stop here.
+            current = current is Visual ? VisualTreeHelper.GetParent(current) : null;
+        }
+        return null;
+    }
+
+    private static bool IsVisualDescendant(DependencyObject? root, DependencyObject target)
+    {
+        DependencyObject? current = target;
+        while (current != null)
+        {
+            if (current == root) return true;
+            current = VisualTreeHelper.GetParent(current)
+                      ?? LogicalTreeHelper.GetParent(current);
+        }
+        return false;
+    }
+}
+
+/// <summary>
+/// Selects between a selectable item template and a non-selectable section header template
+/// based on the <see cref="InlinePickerItem.Group"/> value.
+/// </summary>
+internal class PickerItemTemplateSelector : DataTemplateSelector
+{
+    private readonly DataTemplate _selectableTemplate;
+    private readonly DataTemplate _headerTemplate;
+
+    public PickerItemTemplateSelector(DataTemplate selectableTemplate, DataTemplate headerTemplate)
+    {
+        _selectableTemplate = selectableTemplate;
+        _headerTemplate = headerTemplate;
+    }
+
+    public override DataTemplate SelectTemplate(object item, DependencyObject container)
+    {
+        if (item is InlinePickerItem pickerItem
+            && pickerItem.Group == InlinePickerRichTextBox.HeaderGroupTag)
+            return _headerTemplate;
+
+        return _selectableTemplate;
+    }
+}
diff --git a/Text-Grab/Controls/NotifyIconWindow.xaml b/Text-Grab/Controls/NotifyIconWindow.xaml
index 468c4ebd..bd6e13f7 100644
--- a/Text-Grab/Controls/NotifyIconWindow.xaml
+++ b/Text-Grab/Controls/NotifyIconWindow.xaml
@@ -40,8 +40,8 @@
                     <MenuItem
                         x:Name="OpenClipboardImageGrabFrame"
                         Click="OpenClipboardImageGrabFrame_Click"
-                        IsEnabled="False"
-                        Header="Paste in Grab Frame">
+                        Header="Paste in Grab Frame"
+                        IsEnabled="False">
                         <MenuItem.Icon>
                             <wpfui:SymbolIcon Symbol="ImageEdit24" />
                         </MenuItem.Icon>
diff --git a/Text-Grab/Controls/PatternMatchModeDialog.xaml b/Text-Grab/Controls/PatternMatchModeDialog.xaml
new file mode 100644
index 00000000..8dc28a7d
--- /dev/null
+++ b/Text-Grab/Controls/PatternMatchModeDialog.xaml
@@ -0,0 +1,106 @@
+<ui:FluentWindow
+    x:Class="Text_Grab.Controls.PatternMatchModeDialog"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
+    Title="Pattern Match Options"
+    Width="420"
+    Height="450"
+    MinWidth="380"
+    MinHeight="280"
+    WindowStartupLocation="CenterOwner"
+    mc:Ignorable="d">
+    <Window.Resources>
+        <ui:ImageIcon x:Key="TextGrabIcon" Source="/Text-Grab;component/Images/TealSelect40.png" />
+    </Window.Resources>
+
+    <Grid Background="{ui:ThemeResource SolidBackgroundFillColorBaseBrush}">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+        <ui:TitleBar
+            Title="Pattern Match Options"
+            Height="32"
+            Margin="2,2,2,0"
+            Padding="8,2"
+            Icon="{StaticResource TextGrabIcon}" />
+
+        <StackPanel Grid.Row="1" Margin="12">
+            <TextBlock
+                x:Name="PatternNameLabel"
+                Margin="0,0,0,8"
+                FontWeight="SemiBold"
+                Text="Pattern:" />
+
+            <TextBlock Margin="0,0,0,4" Text="Match Mode:" />
+            <StackPanel x:Name="MatchModePanel" Margin="0,0,0,12">
+                <RadioButton
+                    Checked="MatchModeRadioButton_Checked"
+                    Content="First Match"
+                    GroupName="MatchMode"
+                    IsChecked="True"
+                    Tag="first" />
+                <RadioButton
+                    Checked="MatchModeRadioButton_Checked"
+                    Content="Last Match"
+                    GroupName="MatchMode"
+                    Tag="last" />
+                <RadioButton
+                    Checked="MatchModeRadioButton_Checked"
+                    Content="All Matches"
+                    GroupName="MatchMode"
+                    Tag="all" />
+                <RadioButton
+                    Checked="MatchModeRadioButton_Checked"
+                    Content="Specific Match(es)"
+                    GroupName="MatchMode"
+                    Tag="nth" />
+            </StackPanel>
+
+            <StackPanel
+                x:Name="SeparatorPanel"
+                Margin="0,0,0,12"
+                Visibility="Collapsed">
+                <TextBlock Margin="0,0,0,4" Text="Separator:" />
+                <TextBox x:Name="SeparatorTextBox" Text=", " />
+            </StackPanel>
+
+            <StackPanel
+                x:Name="IndicesPanel"
+                Margin="0,0,0,12"
+                Visibility="Collapsed">
+                <TextBlock Margin="0,0,0,4" Text="Match indices (1-based, comma-separated):" />
+                <TextBox
+                    x:Name="IndicesTextBox"
+                    Text="1"
+                    TextChanged="IndicesTextBox_TextChanged" />
+                <TextBlock
+                    x:Name="IndicesErrorText"
+                    Margin="0,4,0,0"
+                    FontSize="11"
+                    Foreground="Red"
+                    Text=""
+                    Visibility="Collapsed" />
+            </StackPanel>
+        </StackPanel>
+
+        <StackPanel
+            Grid.Row="2"
+            Margin="12,0,12,12"
+            HorizontalAlignment="Right"
+            Orientation="Horizontal">
+            <ui:Button
+                x:Name="OkButton"
+                Margin="0,0,6,0"
+                Appearance="Primary"
+                Click="OkButton_Click"
+                Content="OK" />
+            <ui:Button Click="CancelButton_Click" Content="Cancel" />
+        </StackPanel>
+    </Grid>
+</ui:FluentWindow>
diff --git a/Text-Grab/Controls/PatternMatchModeDialog.xaml.cs b/Text-Grab/Controls/PatternMatchModeDialog.xaml.cs
new file mode 100644
index 00000000..8d0f4de7
--- /dev/null
+++ b/Text-Grab/Controls/PatternMatchModeDialog.xaml.cs
@@ -0,0 +1,127 @@
+using System;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using Text_Grab.Models;
+using Wpf.Ui.Controls;
+
+namespace Text_Grab.Controls;
+
+/// <summary>
+/// Dialog shown after the user selects a regex pattern from the inline picker.
+/// Lets them choose match mode (first, last, all, specific indices) and separator.
+/// </summary>
+public partial class PatternMatchModeDialog : FluentWindow
+{
+    /// <summary>
+    /// The configured result. Null if the user cancelled.
+    /// </summary>
+    public TemplatePatternMatch? Result { get; private set; }
+
+    private readonly string _patternId;
+    private readonly string _patternName;
+
+    public PatternMatchModeDialog(string patternId, string patternName)
+    {
+        InitializeComponent();
+        _patternId = patternId;
+        _patternName = patternName;
+        PatternNameLabel.Text = $"Pattern: {patternName}";
+    }
+
+    private void MatchModeRadioButton_Checked(object sender, RoutedEventArgs e)
+    {
+        if (SeparatorPanel == null || IndicesPanel == null)
+            return;
+
+        string mode = GetSelectedMode();
+
+        SeparatorPanel.Visibility = mode is "all" or "nth" ? Visibility.Visible : Visibility.Collapsed;
+        IndicesPanel.Visibility = mode == "nth" ? Visibility.Visible : Visibility.Collapsed;
+    }
+
+    private void IndicesTextBox_TextChanged(object sender, TextChangedEventArgs e)
+    {
+        ValidateIndices();
+    }
+
+    private bool ValidateIndices()
+    {
+        if (IndicesTextBox == null)
+            return true;
+
+        string text = IndicesTextBox.Text.Trim();
+        if (string.IsNullOrEmpty(text))
+        {
+            ShowIndicesError("At least one index is required.");
+            return false;
+        }
+
+        string[] parts = text.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        if (parts.Length == 0)
+        {
+            ShowIndicesError("At least one index is required.");
+            return false;
+        }
+
+        foreach (string part in parts)
+        {
+            if (!int.TryParse(part, out int val) || val < 1)
+            {
+                ShowIndicesError($"\"{part}\" is not a valid positive integer.");
+                return false;
+            }
+        }
+
+        HideIndicesError();
+        return true;
+    }
+
+    private void ShowIndicesError(string message)
+    {
+        if (IndicesErrorText == null || OkButton == null)
+            return;
+        IndicesErrorText.Text = message;
+        IndicesErrorText.Visibility = Visibility.Visible;
+        OkButton.IsEnabled = false;
+    }
+
+    private void HideIndicesError()
+    {
+        if (IndicesErrorText == null || OkButton == null)
+            return;
+        IndicesErrorText.Visibility = Visibility.Collapsed;
+        OkButton.IsEnabled = true;
+    }
+
+    private string GetSelectedMode()
+    {
+        if (MatchModePanel?.Children.OfType<RadioButton>().FirstOrDefault(button => button.IsChecked == true) is RadioButton button)
+            return button.Tag?.ToString() ?? "first";
+
+        return "first";
+    }
+
+    private void OkButton_Click(object sender, RoutedEventArgs e)
+    {
+        string mode = GetSelectedMode();
+        string separator = SeparatorTextBox.Text;
+
+        if (mode == "nth")
+        {
+            if (!ValidateIndices())
+                return;
+            mode = IndicesTextBox.Text.Trim();
+        }
+
+        Result = new TemplatePatternMatch(_patternId, _patternName, mode, separator);
+        DialogResult = true;
+        Close();
+    }
+
+    private void CancelButton_Click(object sender, RoutedEventArgs e)
+    {
+        DialogResult = false;
+        Close();
+    }
+}
diff --git a/Text-Grab/Controls/PostGrabActionEditor.xaml b/Text-Grab/Controls/PostGrabActionEditor.xaml
index 3126b4c2..b2c9b960 100644
--- a/Text-Grab/Controls/PostGrabActionEditor.xaml
+++ b/Text-Grab/Controls/PostGrabActionEditor.xaml
@@ -1,4 +1,4 @@
-<ui:FluentWindow
+<ui:FluentWindow
     x:Class="Text_Grab.Controls.PostGrabActionEditor"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
@@ -8,7 +8,7 @@
     xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
     Title="Post-Grab Actions Settings"
     Width="900"
-    Height="550"
+    Height="700"
     Background="{DynamicResource ApplicationBackgroundBrush}"
     Foreground="{DynamicResource TextFillColorPrimaryBrush}"
     WindowStartupLocation="CenterOwner"
@@ -29,6 +29,7 @@
         <Grid.RowDefinitions>
             <RowDefinition Height="Auto" />
             <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" MaxHeight="400" />
             <RowDefinition Height="Auto" />
         </Grid.RowDefinitions>
 
@@ -41,22 +42,30 @@
             Icon="{StaticResource TextGrabIcon}" />
 
         <!--  Available Actions (Left)  -->
-        <StackPanel
+        <Grid
             Grid.Row="1"
             Grid.Column="0"
             Margin="16,16,8,8">
+            <Grid.RowDefinitions>
+                <RowDefinition Height="Auto" />
+                <RowDefinition Height="Auto" />
+                <RowDefinition Height="*" />
+            </Grid.RowDefinitions>
             <TextBlock
+                Grid.Row="0"
                 Margin="0,0,0,8"
                 FontSize="18"
                 FontWeight="SemiBold"
                 Text="Available Actions" />
             <TextBlock
                 x:Name="AvailableActionsHint"
+                Grid.Row="1"
                 Margin="0,0,0,4"
                 Opacity="0.7"
                 Text="Actions that can be added to the enabled list"
                 TextWrapping="Wrap" />
             <Border
+                Grid.Row="2"
                 Background="{ui:ThemeResource CardBackgroundFillColorSecondaryBrush}"
                 BorderBrush="{ui:ThemeResource CardStrokeColorDefaultBrush}"
                 BorderThickness="1"
@@ -64,7 +73,6 @@
                 <Grid>
                     <ui:ListView
                         x:Name="AvailableActionsListBox"
-                        MinHeight="300"
                         d:ItemsSource="{d:SampleData ItemCount=5}"
                         ScrollViewer.HorizontalScrollBarVisibility="Hidden"
                         ScrollViewer.VerticalScrollBarVisibility="Visible">
@@ -97,7 +105,7 @@
                         Visibility="Collapsed" />
                 </Grid>
             </Border>
-        </StackPanel>
+        </Grid>
 
         <!--  Move Buttons (Center)  -->
         <StackPanel
@@ -156,73 +164,268 @@
         </StackPanel>
 
         <!--  Enabled Actions (Right)  -->
-        <StackPanel
-            Grid.Row="1"
-            Grid.Column="2"
-            Margin="8,16,16,8">
-            <TextBlock
-                Margin="0,0,0,8"
-                FontSize="18"
-                FontWeight="SemiBold"
-                Text="Enabled Actions" />
-            <TextBlock
-                Margin="0,0,0,4"
-                Opacity="0.7"
-                Text="Actions that will appear in the post-grab menu"
-                TextWrapping="Wrap" />
-            <Border
-                Background="{ui:ThemeResource CardBackgroundFillColorSecondaryBrush}"
-                BorderBrush="{ui:ThemeResource CardStrokeColorDefaultBrush}"
-                BorderThickness="1"
-                CornerRadius="8">
-                <ui:ListView
-                    x:Name="EnabledActionsListBox"
-                    MinHeight="300"
-                    d:ItemsSource="{d:SampleData ItemCount=5}"
-                    ScrollViewer.HorizontalScrollBarVisibility="Hidden"
-                    ScrollViewer.VerticalScrollBarVisibility="Visible">
-                    <ListView.View>
-                        <GridView>
-                            <GridViewColumn Width="46" Header="Icon">
-                                <GridViewColumn.CellTemplate>
-                                    <DataTemplate>
-                                        <Viewbox Height="24">
-                                            <ui:SymbolIcon FontSize="24" Symbol="{Binding Path=SymbolIcon, Mode=OneWay}" />
-                                        </Viewbox>
-                                    </DataTemplate>
-                                </GridViewColumn.CellTemplate>
-                            </GridViewColumn>
-                            <GridViewColumn
-                                Width="180"
-                                DisplayMemberBinding="{Binding ButtonText}"
-                                Header="Action Name" />
-                            <GridViewColumn Width="120" Header="Default">
-                                <GridViewColumn.CellTemplate>
-                                    <DataTemplate>
-                                        <ComboBox Width="110" SelectedIndex="{Binding Path=DefaultCheckState, Mode=TwoWay, Converter={StaticResource EnumToIntConverter}}">
-                                            <ComboBoxItem Content="Off" />
-                                            <ComboBoxItem Content="Last Used" />
-                                            <ComboBoxItem Content="On" />
-                                        </ComboBox>
-                                    </DataTemplate>
-                                </GridViewColumn.CellTemplate>
-                            </GridViewColumn>
-                        </GridView>
-                    </ListView.View>
-                </ui:ListView>
-            </Border>
+        <Grid Grid.Row="1" Grid.Column="2">
+            <Grid Margin="8,16,16,8">
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="*" />
+                    <RowDefinition Height="Auto" />
+                </Grid.RowDefinitions>
+                <TextBlock
+                    Grid.Row="0"
+                    Margin="0,0,0,8"
+                    FontSize="18"
+                    FontWeight="SemiBold"
+                    Text="Enabled Actions" />
+                <TextBlock
+                    Grid.Row="1"
+                    Margin="0,0,0,4"
+                    Opacity="0.7"
+                    Text="Actions that will appear in the post-grab menu"
+                    TextWrapping="Wrap" />
+                <Border
+                    Grid.Row="2"
+                    Background="{ui:ThemeResource CardBackgroundFillColorSecondaryBrush}"
+                    BorderBrush="{ui:ThemeResource CardStrokeColorDefaultBrush}"
+                    BorderThickness="1"
+                    CornerRadius="8">
+                    <ui:ListView
+                        x:Name="EnabledActionsListBox"
+                        d:ItemsSource="{d:SampleData ItemCount=5}"
+                        ScrollViewer.HorizontalScrollBarVisibility="Hidden"
+                        ScrollViewer.VerticalScrollBarVisibility="Visible">
+                        <ListView.View>
+                            <GridView>
+                                <GridViewColumn Width="46" Header="Icon">
+                                    <GridViewColumn.CellTemplate>
+                                        <DataTemplate>
+                                            <Viewbox Height="24">
+                                                <ui:SymbolIcon FontSize="24" Symbol="{Binding Path=SymbolIcon, Mode=OneWay}" />
+                                            </Viewbox>
+                                        </DataTemplate>
+                                    </GridViewColumn.CellTemplate>
+                                </GridViewColumn>
+                                <GridViewColumn
+                                    Width="180"
+                                    DisplayMemberBinding="{Binding ButtonText}"
+                                    Header="Action Name" />
+                                <GridViewColumn Width="120" Header="Default">
+                                    <GridViewColumn.CellTemplate>
+                                        <DataTemplate>
+                                            <ComboBox Width="110" SelectedIndex="{Binding Path=DefaultCheckState, Mode=TwoWay, Converter={StaticResource EnumToIntConverter}}">
+                                                <ComboBoxItem Content="Off" />
+                                                <ComboBoxItem Content="Last Used" />
+                                                <ComboBoxItem Content="On" />
+                                            </ComboBox>
+                                        </DataTemplate>
+                                    </GridViewColumn.CellTemplate>
+                                </GridViewColumn>
+                            </GridView>
+                        </ListView.View>
+                    </ui:ListView>
+                </Border>
 
-            <!--  Stay Open Toggle  -->
-            <ui:ToggleSwitch
-                x:Name="StayOpenToggle"
-                Margin="0,16,0,0"
-                Content="Keep menu open after clicking an action"
-                ToolTip="When enabled, the post-grab menu stays open after clicking an action, allowing multiple actions to be selected" />
-        </StackPanel>
+                <!--  Stay Open Toggle  -->
+                <ui:ToggleSwitch
+                    x:Name="StayOpenToggle"
+                    Grid.Row="3"
+                    Margin="0,16,0,0"
+                    Content="Keep menu open after clicking an action"
+                    ToolTip="When enabled, the post-grab menu stays open after clicking an action, allowing multiple actions to be selected" />
+            </Grid>
+        </Grid>
+
+        <!--  Grab Templates Section  -->
+        <Border
+            Grid.Row="2"
+            Grid.Column="0"
+            Grid.ColumnSpan="3"
+            Margin="16,0,16,8"
+            Background="{ui:ThemeResource CardBackgroundFillColorSecondaryBrush}"
+            BorderBrush="{ui:ThemeResource CardStrokeColorDefaultBrush}"
+            BorderThickness="1"
+            CornerRadius="8">
+            <Grid Margin="12,10">
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
+                </Grid.RowDefinitions>
+
+                <!--  Header + buttons  -->
+                <Grid Grid.Row="0" Margin="0,0,0,8">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="*" />
+                        <ColumnDefinition Width="Auto" />
+                    </Grid.ColumnDefinitions>
+
+                    <StackPanel Grid.Column="0" VerticalAlignment="Center">
+                        <TextBlock
+                            FontSize="16"
+                            FontWeight="SemiBold"
+                            Text="Grab Templates" />
+                        <TextBlock
+                            FontSize="11"
+                            Opacity="0.7"
+                            Text="Templates extract structured data from fixed-layout documents. Click 'New Template from Image' to pick a reference image, then use Ctrl+drag to draw regions and save. Add a template to the Enabled Actions list to use it during a Fullscreen Grab."
+                            TextWrapping="Wrap" />
+                    </StackPanel>
+
+                    <StackPanel
+                        Grid.Column="1"
+                        VerticalAlignment="Center"
+                        Orientation="Horizontal">
+                        <ui:Button
+                            x:Name="NewTemplateFromImageButton"
+                            Margin="0,0,6,0"
+                            Click="NewTemplateFromImageButton_Click"
+                            ToolTip="Pick an image to use as reference for a new grab template">
+                            <StackPanel Orientation="Horizontal">
+                                <ui:SymbolIcon FontSize="14" Symbol="ImageAdd24" />
+                                <TextBlock Margin="4,0,0,0" Text="New Template from Image" />
+                            </StackPanel>
+                        </ui:Button>
+                        <ui:Button
+                            x:Name="EditTemplateRegionsButton"
+                            Margin="0,0,6,0"
+                            Click="EditTemplateRegionsButton_Click"
+                            ToolTip="Open the selected template in a Grab Frame to edit its regions">
+                            <StackPanel Orientation="Horizontal">
+                                <ui:SymbolIcon FontSize="14" Symbol="Edit24" />
+                                <TextBlock Margin="4,0,0,0" Text="Edit Grab Template" />
+                            </StackPanel>
+                        </ui:Button>
+                        <ui:Button
+                            x:Name="DeleteTemplateButton"
+                            Click="DeleteTemplateButton_Click"
+                            ToolTip="Delete the selected Grab Template">
+                            <StackPanel Orientation="Horizontal">
+                                <ui:SymbolIcon FontSize="14" Symbol="Delete24" />
+                                <TextBlock Margin="4,0,0,0" Text="Delete" />
+                            </StackPanel>
+                        </ui:Button>
+                    </StackPanel>
+                </Grid>
+
+                <!--  Templates list  -->
+                <Grid Grid.Row="1">
+                    <ui:ListView
+                        x:Name="TemplatesListBox"
+                        ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                        ScrollViewer.VerticalScrollBarVisibility="Auto"
+                        SelectionChanged="TemplatesListBox_SelectionChanged">
+                        <ListView.View>
+                            <GridView>
+                                <GridViewColumn
+                                    Width="220"
+                                    DisplayMemberBinding="{Binding Name}"
+                                    Header="Template Name" />
+                                <GridViewColumn Width="70" Header="Regions">
+                                    <GridViewColumn.CellTemplate>
+                                        <DataTemplate>
+                                            <TextBlock Text="{Binding Regions.Count}" TextAlignment="Center" />
+                                        </DataTemplate>
+                                    </GridViewColumn.CellTemplate>
+                                </GridViewColumn>
+                                <GridViewColumn
+                                    Width="300"
+                                    DisplayMemberBinding="{Binding OutputTemplate}"
+                                    Header="Output Template" />
+                                <GridViewColumn Width="140" Header="Last Used">
+                                    <GridViewColumn.CellTemplate>
+                                        <DataTemplate>
+                                            <TextBlock Opacity="0.7" Text="{Binding LastUsedDate, StringFormat={}{0:g}}" />
+                                        </DataTemplate>
+                                    </GridViewColumn.CellTemplate>
+                                </GridViewColumn>
+                            </GridView>
+                        </ListView.View>
+                    </ui:ListView>
+                    <TextBlock
+                        x:Name="NoTemplatesText"
+                        Margin="20"
+                        HorizontalAlignment="Center"
+                        VerticalAlignment="Center"
+                        Opacity="0.6"
+                        Text="No templates defined yet. Click 'Open Grab Frame', use Ctrl+drag to draw regions, then click the Save as Template button in the Grab Frame."
+                        TextWrapping="Wrap"
+                        Visibility="Collapsed" />
+                </Grid>
+
+                <!--  Inline template editor (collapsed until Edit is clicked)  -->
+                <Border
+                    x:Name="TemplateEditPanel"
+                    Grid.Row="2"
+                    Margin="0,8,0,0"
+                    Padding="0,8,0,0"
+                    BorderBrush="{ui:ThemeResource CardStrokeColorDefaultBrush}"
+                    BorderThickness="0,1,0,0"
+                    Visibility="Collapsed">
+                    <Grid>
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="Auto" />
+                            <ColumnDefinition Width="*" />
+                        </Grid.ColumnDefinitions>
+                        <Grid.RowDefinitions>
+                            <RowDefinition Height="Auto" />
+                            <RowDefinition Height="Auto" />
+                            <RowDefinition Height="Auto" />
+                        </Grid.RowDefinitions>
+
+                        <TextBlock
+                            Grid.Row="0"
+                            Margin="0,0,8,4"
+                            VerticalAlignment="Center"
+                            Text="Name:" />
+                        <TextBox
+                            x:Name="EditTemplateNameBox"
+                            Grid.Row="0"
+                            Grid.Column="1"
+                            Margin="0,0,0,4"
+                            Padding="4,2"
+                            VerticalContentAlignment="Center" />
+
+                        <TextBlock
+                            Grid.Row="1"
+                            Margin="0,0,8,4"
+                            VerticalAlignment="Center"
+                            Text="Output Template:" />
+                        <TextBox
+                            x:Name="EditOutputTemplateBox"
+                            Grid.Row="1"
+                            Grid.Column="1"
+                            Margin="0,0,0,4"
+                            Padding="4,2"
+                            VerticalContentAlignment="Center"
+                            FontFamily="Consolas"
+                            ToolTip="Use {1}, {2}, etc. for region values. Use {1:trim}, {1:upper}, {1:lower} for formatting. Use \n for newline." />
+
+                        <StackPanel
+                            Grid.Row="2"
+                            Grid.Column="1"
+                            Margin="0,4,0,0"
+                            HorizontalAlignment="Right"
+                            Orientation="Horizontal">
+                            <ui:Button
+                                x:Name="ApplyTemplateEditButton"
+                                Margin="0,0,8,0"
+                                Appearance="Primary"
+                                Click="ApplyTemplateEdit_Click"
+                                Content="Apply Changes" />
+                            <ui:Button
+                                x:Name="CancelTemplateEditButton"
+                                Click="CancelTemplateEdit_Click"
+                                Content="Cancel" />
+                        </StackPanel>
+                    </Grid>
+                </Border>
+            </Grid>
+        </Border>
 
         <!--  Bottom Buttons  -->
         <StackPanel
-            Grid.Row="2"
+            Grid.Row="3"
             Grid.Column="0"
             Grid.ColumnSpan="3"
             Margin="16,8"
diff --git a/Text-Grab/Controls/PostGrabActionEditor.xaml.cs b/Text-Grab/Controls/PostGrabActionEditor.xaml.cs
index a050266a..6f037f7b 100644
--- a/Text-Grab/Controls/PostGrabActionEditor.xaml.cs
+++ b/Text-Grab/Controls/PostGrabActionEditor.xaml.cs
@@ -2,11 +2,13 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
+using System.IO;
 using System.Linq;
 using System.Windows;
 using System.Windows.Data;
 using Text_Grab.Models;
 using Text_Grab.Utilities;
+using Text_Grab.Views;
 using Wpf.Ui.Controls;
 
 namespace Text_Grab.Controls;
@@ -37,6 +39,7 @@ public partial class PostGrabActionEditor : FluentWindow
 
     private ObservableCollection<ButtonInfo> AvailableActions { get; set; }
     private ObservableCollection<ButtonInfo> EnabledActions { get; set; }
+    private GrabTemplate? _editingTemplate;
 
     #endregion Properties
 
@@ -73,6 +76,9 @@ public PostGrabActionEditor()
 
         // Update empty state visibility
         UpdateEmptyStateVisibility();
+
+        // Load templates
+        LoadTemplates();
     }
 
     #endregion Constructors
@@ -199,5 +205,158 @@ private void UpdateEmptyStateVisibility()
         }
     }
 
+    private void LoadTemplates()
+    {
+        List<GrabTemplate> templates = GrabTemplateManager.GetAllTemplates();
+        TemplatesListBox.ItemsSource = templates;
+        UpdateTemplateEmptyState(templates.Count);
+    }
+
+    private void UpdateTemplateEmptyState(int count)
+    {
+        bool hasTemplates = count > 0;
+        TemplatesListBox.Visibility = hasTemplates ? Visibility.Visible : Visibility.Collapsed;
+        NoTemplatesText.Visibility = hasTemplates ? Visibility.Collapsed : Visibility.Visible;
+    }
+
+    private void NewTemplateFromImageButton_Click(object sender, RoutedEventArgs e)
+    {
+        Microsoft.Win32.OpenFileDialog dlg = new()
+        {
+            Filter = FileUtilities.GetImageFilter()
+        };
+
+        if (dlg.ShowDialog() is not true)
+            return;
+
+        string imagePath = dlg.FileName;
+        if (!File.Exists(imagePath))
+            return;
+
+        GrabTemplate newTemplate = new()
+        {
+            Name = Path.GetFileNameWithoutExtension(imagePath),
+            SourceImagePath = imagePath
+        };
+
+        GrabFrame grabFrame = new(newTemplate);
+        grabFrame.Closed += (_, _) => RefreshTemplatesAndActions();
+        grabFrame.Show();
+        grabFrame.Activate();
+    }
+
+    private void EditTemplateRegionsButton_Click(object sender, RoutedEventArgs e)
+    {
+        if (TemplatesListBox.SelectedItem is not GrabTemplate selected)
+        {
+            System.Windows.MessageBox.Show(
+                "Select a template from the list first.",
+                "No Template Selected",
+                System.Windows.MessageBoxButton.OK,
+                System.Windows.MessageBoxImage.Information);
+            return;
+        }
+
+        GrabFrame grabFrame = new(selected);
+        grabFrame.Closed += (_, _) => RefreshTemplatesAndActions();
+        grabFrame.Show();
+        grabFrame.Activate();
+    }
+
+    private void DeleteTemplateButton_Click(object sender, RoutedEventArgs e)
+    {
+        if (TemplatesListBox.SelectedItem is not GrabTemplate selected)
+            return;
+
+        System.Windows.MessageBoxResult result = System.Windows.MessageBox.Show(
+            $"Delete template '{selected.Name}'?",
+            "Delete Template",
+            System.Windows.MessageBoxButton.YesNo,
+            System.Windows.MessageBoxImage.Question);
+
+        if (result != System.Windows.MessageBoxResult.Yes)
+            return;
+
+        GrabTemplateManager.DeleteTemplate(selected.Id);
+
+        // Also remove any enabled action tied to this template
+        ButtonInfo? toRemove = EnabledActions.FirstOrDefault(a => a.TemplateId == selected.Id);
+        if (toRemove is not null)
+            EnabledActions.Remove(toRemove);
+
+        RefreshTemplatesAndActions();
+    }
+
+    private void RefreshTemplatesAndActions()
+    {
+        LoadTemplates();
+
+        // Rebuild available actions list to include/exclude updated templates
+        List<ButtonInfo> allActions = PostGrabActionManager.GetAvailablePostGrabActions();
+        List<ButtonInfo> enabledIds = [.. EnabledActions];
+
+        AvailableActions.Clear();
+        foreach (ButtonInfo action in allActions
+            .Where(a => !enabledIds.Any(e => e.ButtonText == a.ButtonText && e.TemplateId == a.TemplateId))
+            .OrderBy(a => a.OrderNumber))
+        {
+            AvailableActions.Add(action);
+        }
+
+        UpdateEmptyStateVisibility();
+    }
+
+    private void TemplatesListBox_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
+    {
+        if (_editingTemplate is null)
+            return;
+
+        if (TemplatesListBox.SelectedItem is GrabTemplate selected && selected.Id != _editingTemplate.Id)
+        {
+            _editingTemplate = null;
+            TemplateEditPanel.Visibility = Visibility.Collapsed;
+        }
+    }
+
+    private void EditTemplateButton_Click(object sender, RoutedEventArgs e)
+    {
+        if (TemplatesListBox.SelectedItem is not GrabTemplate selected)
+            return;
+
+        _editingTemplate = selected;
+        EditTemplateNameBox.Text = selected.Name;
+        EditOutputTemplateBox.Text = selected.OutputTemplate;
+        TemplateEditPanel.Visibility = Visibility.Visible;
+        EditTemplateNameBox.Focus();
+        EditTemplateNameBox.SelectAll();
+    }
+
+    private void ApplyTemplateEdit_Click(object sender, RoutedEventArgs e)
+    {
+        if (_editingTemplate is null)
+            return;
+
+        string newName = EditTemplateNameBox.Text.Trim();
+        if (string.IsNullOrWhiteSpace(newName))
+        {
+            EditTemplateNameBox.Focus();
+            return;
+        }
+
+        _editingTemplate.Name = newName;
+        _editingTemplate.OutputTemplate = EditOutputTemplateBox.Text;
+        GrabTemplateManager.AddOrUpdateTemplate(_editingTemplate);
+
+        _editingTemplate = null;
+        TemplateEditPanel.Visibility = Visibility.Collapsed;
+        RefreshTemplatesAndActions();
+    }
+
+    private void CancelTemplateEdit_Click(object sender, RoutedEventArgs e)
+    {
+        _editingTemplate = null;
+        TemplateEditPanel.Visibility = Visibility.Collapsed;
+    }
+
     #endregion Methods
 }
diff --git a/Text-Grab/Controls/WordBorder.xaml b/Text-Grab/Controls/WordBorder.xaml
index fdd869cd..833e9588 100644
--- a/Text-Grab/Controls/WordBorder.xaml
+++ b/Text-Grab/Controls/WordBorder.xaml
@@ -160,6 +160,21 @@
                 </Viewbox>
             </Grid>
         </Border>
+        <Border
+            HorizontalAlignment="Left"
+            VerticalAlignment="Top"
+            Background="#CC1F6B78"
+            CornerRadius="0,0,4,0"
+            Padding="3,1"
+            Panel.ZIndex="10"
+            Visibility="{Binding Path=TemplateBadgeVisibility, ElementName=WordBorderControl}">
+            <TextBlock
+                FontFamily="Segoe UI"
+                FontSize="9"
+                FontWeight="Bold"
+                Foreground="White"
+                Text="{Binding Path=TemplateBadgeText, ElementName=WordBorderControl}" />
+        </Border>
         <Border
             Name="MoveResizeBorder"
             d:Visibility="Visible"
diff --git a/Text-Grab/Controls/WordBorder.xaml.cs b/Text-Grab/Controls/WordBorder.xaml.cs
index 08e89600..41f94eb6 100644
--- a/Text-Grab/Controls/WordBorder.xaml.cs
+++ b/Text-Grab/Controls/WordBorder.xaml.cs
@@ -24,6 +24,19 @@ public partial class WordBorder : UserControl, INotifyPropertyChanged
     public static readonly DependencyProperty WordProperty =
         DependencyProperty.Register("Word", typeof(string), typeof(WordBorder), new PropertyMetadata(""));
 
+    public static readonly DependencyProperty TemplateIndexProperty =
+        DependencyProperty.Register(nameof(TemplateIndex), typeof(int), typeof(WordBorder),
+            new PropertyMetadata(0, OnTemplateIndexChanged));
+
+    private static void OnTemplateIndexChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if (d is WordBorder wb)
+        {
+            wb.PropertyChanged?.Invoke(wb, new PropertyChangedEventArgs(nameof(TemplateBadgeVisibility)));
+            wb.PropertyChanged?.Invoke(wb, new PropertyChangedEventArgs(nameof(TemplateBadgeText)));
+        }
+    }
+
     public static RoutedCommand MergeWordsCommand = new();
     private int contextMenuBaseSize;
     private SolidColorBrush contrastingForeground = new(Colors.White);
@@ -133,6 +146,16 @@ public double Top
         }
     }
 
+    public int TemplateIndex
+    {
+        get => (int)GetValue(TemplateIndexProperty);
+        set => SetValue(TemplateIndexProperty, value);
+    }
+
+    public Visibility TemplateBadgeVisibility => TemplateIndex > 0 ? Visibility.Visible : Visibility.Collapsed;
+
+    public string TemplateBadgeText => TemplateIndex > 0 ? $"{{{TemplateIndex}}}" : string.Empty;
+
     public bool WasRegionSelected { get; set; } = false;
     public string Word
     {
@@ -151,7 +174,29 @@ public string Word
     public void Deselect()
     {
         IsSelected = false;
-        WordBorderBorder.BorderBrush = new SolidColorBrush(Color.FromArgb(255, 48, 142, 152));
+        ApplyTemplateStateBorderBrush();
+    }
+
+    private bool _isInOutputPattern = false;
+
+    /// <summary>
+    /// Highlights the border orange when this region is referenced in the output template.
+    /// Call with false to restore the normal teal border color.
+    /// </summary>
+    public void SetHighlightedForOutput(bool isHighlighted)
+    {
+        _isInOutputPattern = isHighlighted;
+        if (!IsSelected)
+            ApplyTemplateStateBorderBrush();
+    }
+
+    private void ApplyTemplateStateBorderBrush()
+    {
+        SolidColorBrush brush = _isInOutputPattern
+            ? new SolidColorBrush(Colors.Orange)
+            : new SolidColorBrush(Color.FromRgb(48, 142, 152));
+        WordBorderBorder.BorderBrush = brush;
+        MoveResizeBorder.BorderBrush = brush;
     }
 
     public void EnterEdit()
diff --git a/Text-Grab/Enums.cs b/Text-Grab/Enums.cs
index ebc238a0..272e1dcb 100644
--- a/Text-Grab/Enums.cs
+++ b/Text-Grab/Enums.cs
@@ -98,3 +98,11 @@ public enum FsgDefaultMode
     SingleLine = 1,
     Table = 2,
 }
+
+public enum FsgSelectionStyle
+{
+    Region = 0,
+    Window = 1,
+    Freeform = 2,
+    AdjustAfter = 3,
+}
diff --git a/Text-Grab/Extensions/ControlExtensions.cs b/Text-Grab/Extensions/ControlExtensions.cs
index 7ccfe990..7174705d 100644
--- a/Text-Grab/Extensions/ControlExtensions.cs
+++ b/Text-Grab/Extensions/ControlExtensions.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Windows;
 using System.Windows.Controls;
 
@@ -5,18 +6,39 @@ namespace Text_Grab;
 
 public static class ControlExtensions
 {
-
-
-
     public static double GetHorizontalScaleFactor(this Viewbox viewbox)
     {
         if (viewbox.Child is not FrameworkElement childElement)
             return 1.0;
 
         double outsideWidth = viewbox.ActualWidth;
+        double outsideHeight = viewbox.ActualHeight;
         double insideWidth = childElement.ActualWidth;
+        double insideHeight = childElement.ActualHeight;
+
+        if (!double.IsFinite(outsideWidth) || !double.IsFinite(insideWidth)
+            || outsideWidth <= 0 || insideWidth <= 4)
+        {
+            return 1.0;
+        }
+
+        // A Viewbox with Stretch="Uniform" applies min(width_ratio, height_ratio) so that
+        // the content fits in both dimensions. Using only the width ratio produces the wrong
+        // scale when the image is height-limited (taller relative to the window than it is
+        // wide), which causes OCR word borders to be placed at incorrect canvas positions.
+        double scale = outsideWidth / insideWidth;
+
+        if (double.IsFinite(outsideHeight) && double.IsFinite(insideHeight)
+            && outsideHeight > 0 && insideHeight > 4)
+        {
+            double scaleY = outsideHeight / insideHeight;
+            scale = Math.Min(scale, scaleY);
+        }
+
+        if (!double.IsFinite(scale) || scale <= 0)
+            return 1.0;
 
-        return outsideWidth / insideWidth;
+        return scale;
     }
 
     public static Rect GetAbsolutePlacement(this FrameworkElement element, bool relativeToScreen = false)
diff --git a/Text-Grab/Models/ButtonInfo.cs b/Text-Grab/Models/ButtonInfo.cs
index a21b39e9..ce3706c8 100644
--- a/Text-Grab/Models/ButtonInfo.cs
+++ b/Text-Grab/Models/ButtonInfo.cs
@@ -30,6 +30,12 @@ public class ButtonInfo
     public bool IsRelevantForEditWindow { get; set; } = true; // Default to true for backward compatibility
     public DefaultCheckState DefaultCheckState { get; set; } = DefaultCheckState.Off;
 
+    /// <summary>
+    /// When this ButtonInfo represents a Grab Template action, this holds the template's
+    /// unique ID so the executor can look it up. Empty for non-template actions.
+    /// </summary>
+    public string TemplateId { get; set; } = string.Empty;
+
     public ButtonInfo()
     {
 
diff --git a/Text-Grab/Models/FullscreenCaptureResult.cs b/Text-Grab/Models/FullscreenCaptureResult.cs
new file mode 100644
index 00000000..a452aaa0
--- /dev/null
+++ b/Text-Grab/Models/FullscreenCaptureResult.cs
@@ -0,0 +1,18 @@
+using System.Windows;
+using System.Windows.Media.Imaging;
+
+namespace Text_Grab.Models;
+
+public record FullscreenCaptureResult(
+    FsgSelectionStyle SelectionStyle,
+    Rect CaptureRegion,
+    BitmapSource? CapturedImage = null,
+    string? WindowTitle = null)
+{
+    public bool SupportsTemplateActions => SelectionStyle != FsgSelectionStyle.Freeform;
+
+    public bool SupportsPreviousRegionReplay =>
+        SelectionStyle is FsgSelectionStyle.Region or FsgSelectionStyle.AdjustAfter;
+
+    public bool UsesCapturedImage => CapturedImage is not null;
+}
diff --git a/Text-Grab/Models/GrabTemplate.cs b/Text-Grab/Models/GrabTemplate.cs
new file mode 100644
index 00000000..986de995
--- /dev/null
+++ b/Text-Grab/Models/GrabTemplate.cs
@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+
+namespace Text_Grab.Models;
+
+/// <summary>
+/// Defines a reusable capture template: a set of numbered named regions on a fixed-layout
+/// document (e.g. a business card or invoice) and an output format string that assembles
+/// the OCR results from those regions into final text.
+///
+/// Output template syntax — region placeholders:
+///   {N}          — replaced by the OCR text from region N  (1-based)
+///   {N:trim}     — trimmed OCR text from region N
+///   {N:upper}    — uppercased OCR text from region N
+///   {N:lower}    — lowercased OCR text from region N
+///
+/// Output template syntax — pattern placeholders (regex):
+///   {p:Name:first}     — first regex match of the named pattern
+///   {p:Name:last}      — last regex match
+///   {p:Name:all:, }    — all matches joined by separator
+///   {p:Name:2}         — 2nd match (1-based)
+///   {p:Name:1,3}       — 1st and 3rd matches joined by separator
+///
+/// Escape sequences:
+///   \n           — newline
+///   \t           — tab
+///   \\           — literal backslash
+///   \{           — literal opening brace
+/// </summary>
+public partial class GrabTemplate
+{
+    /// <summary>Unique persistent identifier.</summary>
+    public string Id { get; set; } = Guid.NewGuid().ToString();
+
+    /// <summary>Human-readable name shown in menus and list boxes.</summary>
+    public string Name { get; set; } = string.Empty;
+
+    /// <summary>Optional description shown as a tooltip.</summary>
+    public string Description { get; set; } = string.Empty;
+
+    /// <summary>Date this template was created.</summary>
+    public DateTimeOffset CreatedDate { get; set; } = DateTimeOffset.Now;
+
+    /// <summary>Date this template was last used for capture.</summary>
+    public DateTimeOffset? LastUsedDate { get; set; }
+
+    /// <summary>
+    /// Optional path to a reference image the designer shows as the canvas background.
+    /// May be empty if no reference image was loaded.
+    /// </summary>
+    public string SourceImagePath { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Width of the reference image (pixels). Used to convert ratio ↔ absolute coordinates.
+    /// </summary>
+    public double ReferenceImageWidth { get; set; } = 800;
+
+    /// <summary>
+    /// Height of the reference image (pixels). Used to convert ratio ↔ absolute coordinates.
+    /// </summary>
+    public double ReferenceImageHeight { get; set; } = 600;
+
+    /// <summary>
+    /// The capture regions, each with a 1-based <see cref="TemplateRegion.RegionNumber"/>.
+    /// </summary>
+    public List<TemplateRegion> Regions { get; set; } = [];
+
+    /// <summary>
+    /// Output format string. Use {N}, {N:trim}, {N:upper}, {N:lower} for regions
+    /// and {p:Name:mode} or {p:Name:mode:separator} for pattern matches.
+    /// Example: "Name: {1}\nEmail: {p:Email Address:first}\nPhone: {3}"
+    /// </summary>
+    public string OutputTemplate { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Pattern references used in the output template.
+    /// Each maps a saved <see cref="StoredRegex"/> to a match-selection mode.
+    /// </summary>
+    public List<TemplatePatternMatch> PatternMatches { get; set; } = [];
+
+    public GrabTemplate() { }
+
+    public GrabTemplate(string name)
+    {
+        Name = name;
+    }
+
+    /// <summary>
+    /// Returns whether this template has the minimum required data to be executed.
+    /// A template is valid if it has a name, an output template, and at least one
+    /// region or pattern reference.
+    /// </summary>
+    public bool IsValid =>
+        !string.IsNullOrWhiteSpace(Name)
+        && (Regions.Count > 0 || PatternMatches.Count > 0)
+        && !string.IsNullOrWhiteSpace(OutputTemplate);
+
+    /// <summary>
+    /// Returns all region numbers referenced in the output template.
+    /// </summary>
+    public IEnumerable<int> GetReferencedRegionNumbers()
+    {
+        System.Text.RegularExpressions.MatchCollection matches =
+            RefRegionNumbers().Matches(OutputTemplate);
+
+        foreach (System.Text.RegularExpressions.Match match in matches)
+        {
+            if (int.TryParse(match.Groups[1].Value, out int number))
+                yield return number;
+        }
+    }
+
+    /// <summary>
+    /// Returns all pattern names referenced in the output template via {p:Name:mode} syntax.
+    /// </summary>
+    public IEnumerable<string> GetReferencedPatternNames()
+    {
+        System.Text.RegularExpressions.MatchCollection matches =
+            RefPatternNames().Matches(OutputTemplate);
+
+        foreach (System.Text.RegularExpressions.Match match in matches)
+        {
+            yield return match.Groups[1].Value;
+        }
+    }
+
+    [System.Text.RegularExpressions.GeneratedRegex(@"\{(\d+)(?::[a-z]+)?\}")]
+    private static partial System.Text.RegularExpressions.Regex RefRegionNumbers();
+
+    [System.Text.RegularExpressions.GeneratedRegex(@"\{p:([^:}]+):[^}]+\}")]
+    private static partial System.Text.RegularExpressions.Regex RefPatternNames();
+}
diff --git a/Text-Grab/Models/HistoryInfo.cs b/Text-Grab/Models/HistoryInfo.cs
index a848bb65..b335e397 100644
--- a/Text-Grab/Models/HistoryInfo.cs
+++ b/Text-Grab/Models/HistoryInfo.cs
@@ -35,6 +35,8 @@ public HistoryInfo()
 
     public double DpiScaleFactor { get; set; } = 1.0;
 
+    public FsgSelectionStyle SelectionStyle { get; set; } = FsgSelectionStyle.Region;
+
     public string LanguageTag { get; set; } = string.Empty;
 
     public LanguageKind LanguageKind { get; set; } = LanguageKind.Global;
diff --git a/Text-Grab/Models/LookupItem.cs b/Text-Grab/Models/LookupItem.cs
index b37a599e..448e0a92 100644
--- a/Text-Grab/Models/LookupItem.cs
+++ b/Text-Grab/Models/LookupItem.cs
@@ -12,6 +12,7 @@ public enum LookupItemKind
     Link = 3,
     Command = 4,
     Dynamic = 5,
+    GrabTemplate = 6,
 }
 
 public class LookupItem : IEquatable<LookupItem>
@@ -31,6 +32,7 @@ public Wpf.Ui.Controls.SymbolRegular UiSymbol
                 LookupItemKind.Link => Wpf.Ui.Controls.SymbolRegular.Link24,
                 LookupItemKind.Command => Wpf.Ui.Controls.SymbolRegular.WindowConsole20,
                 LookupItemKind.Dynamic => Wpf.Ui.Controls.SymbolRegular.Flash24,
+                LookupItemKind.GrabTemplate => Wpf.Ui.Controls.SymbolRegular.DocumentTableSearch24,
                 _ => Wpf.Ui.Controls.SymbolRegular.Copy20,
             };
         }
@@ -66,6 +68,8 @@ public LookupItem(HistoryInfo historyInfo)
 
     public HistoryInfo? HistoryItem { get; set; }
 
+    public string? TemplateId { get; set; }
+
     public override string ToString()
     {
         if (HistoryItem is not null)
diff --git a/Text-Grab/Models/PostGrabContext.cs b/Text-Grab/Models/PostGrabContext.cs
new file mode 100644
index 00000000..0644634c
--- /dev/null
+++ b/Text-Grab/Models/PostGrabContext.cs
@@ -0,0 +1,39 @@
+using System.Windows;
+using System.Windows.Media.Imaging;
+using Text_Grab.Interfaces;
+
+namespace Text_Grab.Models;
+
+/// <summary>
+/// Carries all context data produced by a grab action and passed through
+/// the post-grab action pipeline. This allows actions that need only the
+/// OCR text to ignore the extra fields, while template actions can use
+/// the capture region and DPI to re-run sub-region OCR.
+/// </summary>
+public record PostGrabContext(
+    /// <summary>The OCR text extracted from the full capture region.</summary>
+    string Text,
+
+    /// <summary>
+    /// The screen rectangle (in physical pixels) that was captured.
+    /// Used by template execution to derive sub-region rectangles.
+    /// </summary>
+    Rect CaptureRegion,
+
+    /// <summary>The DPI scale factor at capture time.</summary>
+    double DpiScale,
+
+    /// <summary>Optional in-memory copy of the captured image.</summary>
+    BitmapSource? CapturedImage,
+
+    /// <summary>The OCR language used for the capture. Null means use the app default.</summary>
+    ILanguage? Language = null,
+
+    /// <summary>The selection style used to produce the capture.</summary>
+    FsgSelectionStyle SelectionStyle = FsgSelectionStyle.Region
+)
+{
+    /// <summary>Convenience factory for non-template actions that only need text.</summary>
+    public static PostGrabContext TextOnly(string text) =>
+        new(text, Rect.Empty, 1.0, null, null, FsgSelectionStyle.Region);
+}
diff --git a/Text-Grab/Models/TemplatePatternMatch.cs b/Text-Grab/Models/TemplatePatternMatch.cs
new file mode 100644
index 00000000..340641d6
--- /dev/null
+++ b/Text-Grab/Models/TemplatePatternMatch.cs
@@ -0,0 +1,53 @@
+using System;
+
+namespace Text_Grab.Models;
+
+/// <summary>
+/// Represents a reference to a saved regex pattern within a GrabTemplate.
+/// During execution the pattern is applied to the full-area OCR text and
+/// matches are extracted according to <see cref="MatchMode"/>.
+///
+/// Placeholder syntax in the output template:
+///   {p:PatternName:first}       — first match
+///   {p:PatternName:last}        — last match
+///   {p:PatternName:all:, }      — all matches joined by separator
+///   {p:PatternName:2}           — 2nd match (1-based)
+///   {p:PatternName:1,3}         — 1st and 3rd matches joined by separator
+/// </summary>
+public class TemplatePatternMatch
+{
+    /// <summary>
+    /// The <see cref="StoredRegex.Id"/> of the saved pattern.
+    /// Used for durable resolution even if the pattern is renamed.
+    /// </summary>
+    public string PatternId { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Display name of the pattern (mirrors <see cref="StoredRegex.Name"/> at creation time).
+    /// Also used in the <c>{p:PatternName:...}</c> placeholder syntax.
+    /// </summary>
+    public string PatternName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// How to select from the regex matches.
+    /// Values: "first", "last", "all", a single 1-based index like "2",
+    /// or comma-separated indices like "1,3,5".
+    /// </summary>
+    public string MatchMode { get; set; } = "first";
+
+    /// <summary>
+    /// Separator string used when <see cref="MatchMode"/> is "all" or specifies
+    /// multiple indices. Defaults to ", ".
+    /// </summary>
+    public string Separator { get; set; } = ", ";
+
+    public TemplatePatternMatch() { }
+
+    public TemplatePatternMatch(string patternId, string patternName, string matchMode = "first", string separator = ", ")
+    {
+        PatternId = patternId;
+        PatternName = patternName;
+        MatchMode = matchMode;
+        Separator = separator;
+    }
+}
diff --git a/Text-Grab/Models/TemplateRegion.cs b/Text-Grab/Models/TemplateRegion.cs
new file mode 100644
index 00000000..f2a16117
--- /dev/null
+++ b/Text-Grab/Models/TemplateRegion.cs
@@ -0,0 +1,66 @@
+using System.Windows;
+
+namespace Text_Grab.Models;
+
+/// <summary>
+/// Defines a named, numbered capture region within a GrabTemplate.
+/// Positions are stored as ratios (0.0–1.0) of the reference image dimensions
+/// so the template scales to any screen size or DPI.
+/// </summary>
+public class TemplateRegion
+{
+    /// <summary>
+    /// 1-based number shown on the region border and used in the output template as {RegionNumber}.
+    /// </summary>
+    public int RegionNumber { get; set; } = 1;
+
+    /// <summary>
+    /// Optional friendly label for this region (e.g. "Name", "Email").
+    /// Displayed on the border in the designer.
+    /// </summary>
+    public string Label { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Position and size as ratios of the reference image dimensions (each value 0.0–1.0).
+    /// X, Y, Width, Height correspond to left, top, width, height proportions.
+    /// </summary>
+    public double RatioLeft { get; set; } = 0;
+    public double RatioTop { get; set; } = 0;
+    public double RatioWidth { get; set; } = 0;
+    public double RatioHeight { get; set; } = 0;
+
+    /// <summary>
+    /// Optional default/fallback value used when OCR returns empty for this region.
+    /// </summary>
+    public string DefaultValue { get; set; } = string.Empty;
+
+    public TemplateRegion() { }
+
+    /// <summary>
+    /// Returns the absolute pixel Rect for this region given the canvas/image dimensions.
+    /// </summary>
+    public Rect ToAbsoluteRect(double imageWidth, double imageHeight)
+    {
+        return new Rect(
+            x: RatioLeft * imageWidth,
+            y: RatioTop * imageHeight,
+            width: RatioWidth * imageWidth,
+            height: RatioHeight * imageHeight);
+    }
+
+    /// <summary>
+    /// Sets ratio values from an absolute Rect and canvas dimensions.
+    /// </summary>
+    public static TemplateRegion FromAbsoluteRect(Rect rect, double imageWidth, double imageHeight, int regionNumber, string label = "")
+    {
+        return new TemplateRegion
+        {
+            RegionNumber = regionNumber,
+            Label = label,
+            RatioLeft = imageWidth > 0 ? rect.X / imageWidth : 0,
+            RatioTop = imageHeight > 0 ? rect.Y / imageHeight : 0,
+            RatioWidth = imageWidth > 0 ? rect.Width / imageWidth : 0,
+            RatioHeight = imageHeight > 0 ? rect.Height / imageHeight : 0,
+        };
+    }
+}
diff --git a/Text-Grab/Models/WindowSelectionCandidate.cs b/Text-Grab/Models/WindowSelectionCandidate.cs
new file mode 100644
index 00000000..983716a4
--- /dev/null
+++ b/Text-Grab/Models/WindowSelectionCandidate.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Windows;
+
+namespace Text_Grab.Models;
+
+public record WindowSelectionCandidate(IntPtr Handle, Rect Bounds, string Title, int ProcessId, string AppName = "")
+{
+    public bool Contains(Point point) => Bounds.Contains(point);
+
+    public string DisplayAppName => string.IsNullOrWhiteSpace(AppName) ? "Application" : AppName;
+
+    public string DisplayTitle => string.IsNullOrWhiteSpace(Title) ? "Untitled window" : Title;
+}
diff --git a/Text-Grab/OSInterop.cs b/Text-Grab/OSInterop.cs
index 6fa9a8ae..578aa536 100644
--- a/Text-Grab/OSInterop.cs
+++ b/Text-Grab/OSInterop.cs
@@ -1,5 +1,6 @@
-using System;
+using System;
 using System.Runtime.InteropServices;
+using System.Text;
 
 internal static partial class OSInterop
 {
@@ -24,6 +25,42 @@ internal static partial class OSInterop
     [DllImport("user32.dll")]
     public static extern bool ClipCursor([In()] IntPtr lpRect);
 
+    [DllImport("user32.dll")]
+    public static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
+
+    [DllImport("user32.dll")]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
+
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+    public static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
+
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+    public static extern int GetWindowTextLength(IntPtr hWnd);
+
+    [DllImport("user32.dll")]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool IsIconic(IntPtr hWnd);
+
+    [DllImport("user32.dll")]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool IsWindowVisible(IntPtr hWnd);
+
+    [DllImport("user32.dll")]
+    public static extern IntPtr GetShellWindow();
+
+    [DllImport("user32.dll")]
+    public static extern int GetWindowLong(IntPtr hWnd, int nIndex);
+
+    [DllImport("user32.dll")]
+    public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
+
+    [DllImport("dwmapi.dll")]
+    public static extern int DwmGetWindowAttribute(IntPtr hwnd, int dwAttribute, out RECT pvAttribute, int cbAttribute);
+
+    [DllImport("dwmapi.dll")]
+    public static extern int DwmGetWindowAttribute(IntPtr hwnd, int dwAttribute, out int pvAttribute, int cbAttribute);
+
     public struct RECT
     {
         public int left;
@@ -56,6 +93,8 @@ public class MONITORINFOEX
     public const int WM_KEYDOWN = 0x0100;
     public const int WM_KEYUP = 0x0101;
 
+    public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+
     [LibraryImport("kernel32.dll")]
     [return: MarshalAs(UnmanagedType.Bool)]
     internal static partial bool FreeLibrary(IntPtr hModule);
diff --git a/Text-Grab/Pages/FullscreenGrabSettings.xaml b/Text-Grab/Pages/FullscreenGrabSettings.xaml
index 54a6c2a2..19cbf5f1 100644
--- a/Text-Grab/Pages/FullscreenGrabSettings.xaml
+++ b/Text-Grab/Pages/FullscreenGrabSettings.xaml
@@ -10,18 +10,21 @@
     Loaded="Page_Loaded"
     mc:Ignorable="d">
 
-    <StackPanel Margin="20,12,40,40" Orientation="Vertical">
-        <TextBlock Style="{StaticResource TextHeader}" Text="Fullscreen Grab Settings" />
+    <StackPanel Margin="20,12,40,40"
+            Orientation="Vertical">
+        <TextBlock Style="{StaticResource TextHeader}"
+                Text="Fullscreen Grab Settings"/>
 
         <TextBlock
             Margin="0,12,0,6"
             FontSize="18"
             FontWeight="Bold"
             Style="{StaticResource TextBodyNormal}"
-            Text="Defaults" />
+            Text="Defaults"/>
 
         <StackPanel Margin="0,4,0,8">
-            <TextBlock Style="{StaticResource TextBodyNormal}" Text="Start mode:" />
+            <TextBlock Style="{StaticResource TextBodyNormal}"
+                    Text="Start mode:"/>
             <StackPanel Margin="12,6,0,0">
                 <RadioButton
                     x:Name="DefaultModeRadio"
@@ -46,44 +49,80 @@
                 Margin="24,6,0,0"
                 Opacity="0.75"
                 Style="{StaticResource TextBodyNormal}"
-                Text="Single Line outputs captures as a single line (same as pressing S). Table mode requires Windows OCR/AI languages." />
+                Text="Single Line outputs captures as a single line (same as pressing S). Table mode requires Windows OCR/AI languages."/>
+        </StackPanel>
+
+        <StackPanel Margin="0,4,0,8">
+            <TextBlock Style="{StaticResource TextBodyNormal}"
+                    Text="Selection style:"/>
+            <StackPanel Margin="12,6,0,0">
+                <RadioButton
+                    x:Name="RegionSelectionStyleRadio"
+                    Click="RegionSelectionStyleRadio_Click"
+                    GroupName="FsgSelectionStyle">
+                    Rectangle 1 - Drag a box
+                </RadioButton>
+                <RadioButton
+                    x:Name="WindowSelectionStyleRadio"
+                    Click="WindowSelectionStyleRadio_Click"
+                    GroupName="FsgSelectionStyle">
+                    Window - Hover and click
+                </RadioButton>
+                <RadioButton
+                    x:Name="FreeformSelectionStyleRadio"
+                    Click="FreeformSelectionStyleRadio_Click"
+                    GroupName="FsgSelectionStyle">
+                    Freeform - Draw any shape
+                </RadioButton>
+                <RadioButton
+                    x:Name="AdjustAfterSelectionStyleRadio"
+                    Click="AdjustAfterSelectionStyleRadio_Click"
+                    GroupName="FsgSelectionStyle">
+                    Rectangle 2 - Drag, then adjust
+                </RadioButton>
+            </StackPanel>
+            <TextBlock
+                Margin="24,6,0,0"
+                Opacity="0.75"
+                Style="{StaticResource TextBodyNormal}"
+                Text="Choose how Fullscreen Grab defines the capture area by default. Rectangle 1 is the standard drag-a-box capture, and Rectangle 2 lets you fine-tune the box before grabbing."/>
         </StackPanel>
 
         <CheckBox
             x:Name="SendToEtwCheckBox"
             Margin="0,4,0,0"
             Click="SendToEtwCheckBox_Click"
-            Content="Send output to Edit Text Window by default" />
+            Content="Send output to Edit Text Window by default"/>
         <TextBlock
             Margin="24,0,0,8"
             Opacity="0.75"
             Style="{StaticResource TextBodyNormal}"
-            Text="Automatically route capture text into the Edit Text Window (same as pressing E)." />
+            Text="Automatically route capture text into the Edit Text Window (same as pressing E)."/>
 
         <!--  Shade overlay option  -->
         <CheckBox
             x:Name="ShadeOverlayCheckBox"
             Margin="0,8,0,0"
             Click="ShadeOverlayCheckBox_Click"
-            Content="Dim screen with translucent overlay while selecting" />
+            Content="Dim screen with translucent overlay while selecting"/>
         <TextBlock
             Margin="24,0,0,8"
             Opacity="0.75"
             Style="{StaticResource TextBodyNormal}"
-            Text="Controls the transparent overlay shown during Fullscreen Grab selection. Turn off to disable screen dimming." />
+            Text="Controls the transparent overlay shown during Fullscreen Grab selection. Turn off to disable screen dimming."/>
 
         <TextBlock
             Margin="0,16,0,6"
             FontSize="18"
             FontWeight="Bold"
             Style="{StaticResource TextBodyNormal}"
-            Text="Post-capture insert" />
+            Text="Post-capture insert"/>
 
         <CheckBox
             x:Name="TryInsertCheckBox"
             Margin="0,4,0,0"
             Click="TryInsertCheckBox_Click"
-            Content="Insert captured text into the focused app after closing Fullscreen Grab" />
+            Content="Insert captured text into the focused app after closing Fullscreen Grab"/>
 
         <StackPanel
             Margin="24,6,0,0"
@@ -92,7 +131,7 @@
             <TextBlock
                 VerticalAlignment="Center"
                 Style="{StaticResource TextBodyNormal}"
-                Text="Insert delay (seconds):" />
+                Text="Insert delay (seconds):"/>
             <Slider
                 x:Name="InsertDelaySlider"
                 Width="200"
@@ -102,33 +141,33 @@
                 Minimum="0"
                 SmallChange="0.1"
                 TickFrequency="0.1"
-                ValueChanged="InsertDelaySlider_ValueChanged" />
+                ValueChanged="InsertDelaySlider_ValueChanged"/>
             <TextBlock
                 x:Name="InsertDelayValueText"
                 Width="40"
                 Margin="12,0,0,0"
                 HorizontalAlignment="Left"
-                Style="{StaticResource TextBodyNormal}" />
+                Style="{StaticResource TextBodyNormal}"/>
         </StackPanel>
 
         <TextBlock
             Margin="24,2,0,0"
             Opacity="0.75"
             Style="{StaticResource TextBodyNormal}"
-            Text="How long to wait before simulating paste (Ctrl+V)." />
+            Text="How long to wait before simulating paste (Ctrl+V)."/>
 
         <TextBlock
             Margin="0,16,0,6"
             FontSize="18"
             FontWeight="Bold"
             Style="{StaticResource TextBodyNormal}"
-            Text="Post-capture actions" />
+            Text="Post-capture actions"/>
 
         <TextBlock
             Margin="0,0,0,8"
             Opacity="0.75"
             Style="{StaticResource TextBodyNormal}"
-            Text="Configure which actions are performed automatically after text is captured (Fix GUIDs, Trim lines, Remove duplicates, etc.)." />
+            Text="Configure which actions are performed automatically after text is captured (Fix GUIDs, Trim lines, Remove duplicates, etc.)."/>
 
         <Button
             x:Name="CustomizeActionsButton"
@@ -136,13 +175,30 @@
             HorizontalAlignment="Left"
             Click="CustomizeActionsButton_Click"
             Content="Customize Post-Capture Actions..."
-            ToolTip="Open editor to add, remove, and reorder post-capture actions" />
+            ToolTip="Open editor to add, remove, and reorder post-capture actions"/>
 
         <TextBlock
             x:Name="ActionsCountText"
             Margin="0,0,0,16"
             Opacity="0.75"
             Style="{StaticResource TextBodyNormal}"
-            Text="Current actions: Loading..." />
+            Text="Current actions: Loading..."/>
+
+        <TextBlock
+            Margin="0,0,0,4"
+            Style="{StaticResource TextBodyNormal}"
+            Text="Grab Templates"/>
+        <TextBlock
+            Margin="0,0,0,8"
+            Opacity="0.75"
+            Style="{StaticResource TextBodyNormal}"
+            Text="Create reusable templates that OCR specific regions of a captured area and format the result using a template string like &quot;Name: {1}\nEmail: {2}&quot;."/>
+        <Button
+            x:Name="ManageTemplatesButton"
+            Margin="0,0,0,16"
+            HorizontalAlignment="Left"
+            Click="ManageTemplatesButton_Click"
+            Content="Manage Grab Templates..."
+            ToolTip="Open editor to create, edit, and delete grab templates"/>
     </StackPanel>
 </Page>
diff --git a/Text-Grab/Pages/FullscreenGrabSettings.xaml.cs b/Text-Grab/Pages/FullscreenGrabSettings.xaml.cs
index 8f10bcac..01437e24 100644
--- a/Text-Grab/Pages/FullscreenGrabSettings.xaml.cs
+++ b/Text-Grab/Pages/FullscreenGrabSettings.xaml.cs
@@ -54,6 +54,27 @@ private void Page_Loaded(object sender, RoutedEventArgs e)
             DefaultModeRadio.IsChecked = true;
         }
 
+        FsgSelectionStyle selectionStyle = FsgSelectionStyle.Region;
+        if (!string.IsNullOrWhiteSpace(DefaultSettings.FsgSelectionStyle))
+            Enum.TryParse(DefaultSettings.FsgSelectionStyle, true, out selectionStyle);
+
+        switch (selectionStyle)
+        {
+            case FsgSelectionStyle.Window:
+                WindowSelectionStyleRadio.IsChecked = true;
+                break;
+            case FsgSelectionStyle.Freeform:
+                FreeformSelectionStyleRadio.IsChecked = true;
+                break;
+            case FsgSelectionStyle.AdjustAfter:
+                AdjustAfterSelectionStyleRadio.IsChecked = true;
+                break;
+            case FsgSelectionStyle.Region:
+            default:
+                RegionSelectionStyleRadio.IsChecked = true;
+                break;
+        }
+
         // Update post-grab actions count
         UpdateActionsCountText();
 
@@ -85,6 +106,26 @@ private void TableModeRadio_Click(object sender, RoutedEventArgs e)
         DefaultSettings.Save();
     }
 
+    private void RegionSelectionStyleRadio_Click(object sender, RoutedEventArgs e)
+    {
+        SaveSelectionStyle(RegionSelectionStyleRadio, FsgSelectionStyle.Region);
+    }
+
+    private void WindowSelectionStyleRadio_Click(object sender, RoutedEventArgs e)
+    {
+        SaveSelectionStyle(WindowSelectionStyleRadio, FsgSelectionStyle.Window);
+    }
+
+    private void FreeformSelectionStyleRadio_Click(object sender, RoutedEventArgs e)
+    {
+        SaveSelectionStyle(FreeformSelectionStyleRadio, FsgSelectionStyle.Freeform);
+    }
+
+    private void AdjustAfterSelectionStyleRadio_Click(object sender, RoutedEventArgs e)
+    {
+        SaveSelectionStyle(AdjustAfterSelectionStyleRadio, FsgSelectionStyle.AdjustAfter);
+    }
+
     private void SendToEtwCheckBox_Click(object sender, RoutedEventArgs e)
     {
         if (!_loaded) return;
@@ -134,6 +175,18 @@ private void CustomizeActionsButton_Click(object sender, RoutedEventArgs e)
         }
     }
 
+    private void ManageTemplatesButton_Click(object sender, RoutedEventArgs e)
+    {
+        PostGrabActionEditor editor = new()
+        {
+            Owner = Window.GetWindow(this)
+        };
+
+        // ShowDialog returns true only on Save — update count regardless for consistency
+        editor.ShowDialog();
+        UpdateActionsCountText();
+    }
+
     private void UpdateActionsCountText()
     {
         List<ButtonInfo> enabledActions = PostGrabActionManager.GetEnabledPostGrabActions();
@@ -156,4 +209,13 @@ private void UpdateActionsCountText()
             ActionsCountText.Text = $"{count} actions enabled: {actionsList}";
         }
     }
+
+    private void SaveSelectionStyle(RadioButton radioButton, FsgSelectionStyle selectionStyle)
+    {
+        if (!_loaded || radioButton.IsChecked != true)
+            return;
+
+        DefaultSettings.FsgSelectionStyle = selectionStyle.ToString();
+        DefaultSettings.Save();
+    }
 }
diff --git a/Text-Grab/Properties/Settings.Designer.cs b/Text-Grab/Properties/Settings.Designer.cs
index d223017a..05bf5d8e 100644
--- a/Text-Grab/Properties/Settings.Designer.cs
+++ b/Text-Grab/Properties/Settings.Designer.cs
@@ -12,7 +12,7 @@ namespace Text_Grab.Properties {
     
     
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "17.14.0.0")]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "18.4.0.0")]
     internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
         
         private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
@@ -647,6 +647,18 @@ public string FsgDefaultMode {
             }
         }
         
+        [global::System.Configuration.UserScopedSettingAttribute()]
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+        [global::System.Configuration.DefaultSettingValueAttribute("Region")]
+        public string FsgSelectionStyle {
+            get {
+                return ((string)(this["FsgSelectionStyle"]));
+            }
+            set {
+                this["FsgSelectionStyle"] = value;
+            }
+        }
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("True")]
@@ -839,6 +851,18 @@ public bool PostGrabStayOpen {
             }
         }
         
+        [global::System.Configuration.UserScopedSettingAttribute()]
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+        [global::System.Configuration.DefaultSettingValueAttribute("")]
+        public string GrabTemplatesJSON {
+            get {
+                return ((string)(this["GrabTemplatesJSON"]));
+            }
+            set {
+                this["GrabTemplatesJSON"] = value;
+            }
+        }
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
@@ -850,7 +874,7 @@ public bool AddToContextMenu {
                 this["AddToContextMenu"] = value;
             }
         }
-
+        
         [global::System.Configuration.UserScopedSettingAttribute()]
         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
         [global::System.Configuration.DefaultSettingValueAttribute("False")]
diff --git a/Text-Grab/Properties/Settings.settings b/Text-Grab/Properties/Settings.settings
index 63fb72c1..ba7b7aa3 100644
--- a/Text-Grab/Properties/Settings.settings
+++ b/Text-Grab/Properties/Settings.settings
@@ -158,6 +158,9 @@
     <Setting Name="FsgDefaultMode" Type="System.String" Scope="User">
       <Value Profile="(Default)">Default</Value>
     </Setting>
+    <Setting Name="FsgSelectionStyle" Type="System.String" Scope="User">
+      <Value Profile="(Default)">Region</Value>
+    </Setting>
     <Setting Name="FsgShadeOverlay" Type="System.Boolean" Scope="User">
       <Value Profile="(Default)">True</Value>
     </Setting>
@@ -206,6 +209,9 @@
     <Setting Name="PostGrabStayOpen" Type="System.Boolean" Scope="User">
       <Value Profile="(Default)">False</Value>
     </Setting>
+    <Setting Name="GrabTemplatesJSON" Type="System.String" Scope="User">
+      <Value Profile="(Default)" />
+    </Setting>
     <Setting Name="AddToContextMenu" Type="System.Boolean" Scope="User">
       <Value Profile="(Default)">False</Value>
     </Setting>
diff --git a/Text-Grab/Services/SettingsService.cs b/Text-Grab/Services/SettingsService.cs
index fd1cddd8..73bc7d24 100644
--- a/Text-Grab/Services/SettingsService.cs
+++ b/Text-Grab/Services/SettingsService.cs
@@ -98,9 +98,15 @@ public void SaveSettingInContainer<T>(string name, T value)
         {
             _localSettings.Values[name] = value;
         }
+        catch (System.Runtime.InteropServices.COMException ex) when (ex.HResult == unchecked((int)0x80073DC8))
+        {
+            // The value exceeds the ApplicationDataContainer size limit (8 KB).
+            // Large data should be stored in a file instead.
+            Debug.WriteLine($"Setting '{name}' exceeds ApplicationDataContainer size limit: {ex.Message}");
+        }
         catch (Exception ex)
         {
-            Debug.WriteLine($"Failed to Save setting from ApplicationDataContainer {ex.Message}");
+            Debug.WriteLine($"Failed to Save setting in ApplicationDataContainer: {ex.Message}");
 #if DEBUG
             throw;
 #endif
diff --git a/Text-Grab/Styles/ListViewScrollFix.xaml b/Text-Grab/Styles/ListViewScrollFix.xaml
new file mode 100644
index 00000000..3dad6541
--- /dev/null
+++ b/Text-Grab/Styles/ListViewScrollFix.xaml
@@ -0,0 +1,85 @@
+<ResourceDictionary
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:controls="clr-namespace:Wpf.Ui.Controls;assembly=Wpf.Ui">
+
+    <!--
+        Override the WPF-UI GridViewScrollViewerTemplate to add missing ViewportSize bindings.
+        Without ViewportSize, the scrollbar thumb defaults to size 1 regardless of content,
+        making it appear tiny even with only a few items.
+    -->
+    <ControlTemplate x:Key="GridViewScrollViewerTemplate" TargetType="ScrollViewer">
+        <Grid Background="Transparent">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*" />
+                <ColumnDefinition Width="Auto" />
+            </Grid.ColumnDefinitions>
+            <Grid.RowDefinitions>
+                <RowDefinition Height="*" />
+                <RowDefinition Height="Auto" />
+            </Grid.RowDefinitions>
+            <DockPanel Margin="{TemplateBinding Control.Padding}">
+                <ScrollViewer
+                    DockPanel.Dock="Top"
+                    Focusable="False"
+                    HorizontalScrollBarVisibility="Hidden"
+                    VerticalScrollBarVisibility="Hidden">
+                    <controls:GridViewHeaderRowPresenter
+                        Margin="4"
+                        AllowsColumnReorder="{Binding Path=View.AllowsColumnReorder, RelativeSource={RelativeSource AncestorType=ListView}}"
+                        ColumnHeaderContainerStyle="{Binding Path=View.ColumnHeaderContainerStyle, RelativeSource={RelativeSource AncestorType=ListView}}"
+                        ColumnHeaderContextMenu="{Binding Path=View.ColumnHeaderContextMenu, RelativeSource={RelativeSource AncestorType=ListView}}"
+                        ColumnHeaderTemplate="{Binding Path=View.ColumnHeaderTemplate, RelativeSource={RelativeSource AncestorType=ListView}}"
+                        ColumnHeaderToolTip="{Binding Path=View.ColumnHeaderToolTip, RelativeSource={RelativeSource AncestorType=ListView}}"
+                        Columns="{Binding Path=View.Columns, RelativeSource={RelativeSource AncestorType=ListView}}"
+                        SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" />
+                </ScrollViewer>
+                <ScrollContentPresenter
+                    Name="PART_ScrollContentPresenter"
+                    CanContentScroll="{TemplateBinding ScrollViewer.CanContentScroll}"
+                    CanHorizontallyScroll="False"
+                    CanVerticallyScroll="False"
+                    Content="{TemplateBinding ContentControl.Content}"
+                    ContentTemplate="{TemplateBinding ContentControl.ContentTemplate}"
+                    KeyboardNavigation.DirectionalNavigation="Local"
+                    SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" />
+            </DockPanel>
+            <ScrollBar
+                Name="PART_HorizontalScrollBar"
+                Grid.Row="1"
+                Cursor="Arrow"
+                Maximum="{TemplateBinding ScrollViewer.ScrollableWidth}"
+                Minimum="0"
+                Orientation="Horizontal"
+                ViewportSize="{TemplateBinding ScrollViewer.ViewportWidth}"
+                Visibility="{TemplateBinding ScrollViewer.ComputedHorizontalScrollBarVisibility}"
+                Value="{Binding Path=HorizontalOffset, RelativeSource={RelativeSource TemplatedParent}, Mode=OneWay}" />
+            <ScrollBar
+                Name="PART_VerticalScrollBar"
+                Grid.Column="1"
+                Cursor="Arrow"
+                Maximum="{TemplateBinding ScrollViewer.ScrollableHeight}"
+                Minimum="0"
+                Orientation="Vertical"
+                ViewportSize="{TemplateBinding ScrollViewer.ViewportHeight}"
+                Visibility="{TemplateBinding ScrollViewer.ComputedVerticalScrollBarVisibility}"
+                Value="{Binding Path=VerticalOffset, RelativeSource={RelativeSource TemplatedParent}, Mode=OneWay}" />
+            <DockPanel
+                Grid.Row="1"
+                Grid.Column="1"
+                LastChildFill="False">
+                <Rectangle
+                    Width="1"
+                    DockPanel.Dock="Left"
+                    Fill="#FFFFFFFF"
+                    Visibility="{TemplateBinding ScrollViewer.ComputedVerticalScrollBarVisibility}" />
+                <Rectangle
+                    Height="1"
+                    DockPanel.Dock="Top"
+                    Fill="#FFFFFFFF"
+                    Visibility="{TemplateBinding ScrollViewer.ComputedHorizontalScrollBarVisibility}" />
+            </DockPanel>
+        </Grid>
+    </ControlTemplate>
+
+</ResourceDictionary>
diff --git a/Text-Grab/Styles/SelectionStyleComboBoxItemStyle.xaml b/Text-Grab/Styles/SelectionStyleComboBoxItemStyle.xaml
new file mode 100644
index 00000000..183257a0
--- /dev/null
+++ b/Text-Grab/Styles/SelectionStyleComboBoxItemStyle.xaml
@@ -0,0 +1,52 @@
+<ResourceDictionary
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:wpfui="http://schemas.lepo.co/wpfui/2022/xaml">
+    <Style x:Key="SelectionStyleComboBoxItemStyle" TargetType="ComboBoxItem">
+        <Setter Property="Background" Value="Transparent" />
+        <Setter Property="FocusVisualStyle" Value="{x:Null}" />
+        <Setter Property="Foreground" Value="{wpfui:ThemeResource TextFillColorPrimaryBrush}" />
+        <Setter Property="HorizontalContentAlignment" Value="Stretch" />
+        <Setter Property="Padding" Value="10,8" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="ComboBoxItem">
+                    <Border
+                        x:Name="ItemBorder"
+                        Margin="2"
+                        Padding="{TemplateBinding Padding}"
+                        Background="{TemplateBinding Background}"
+                        CornerRadius="4"
+                        SnapsToDevicePixels="True">
+                        <StackPanel Orientation="Horizontal">
+                            <ContentPresenter
+                                HorizontalAlignment="Center"
+                                VerticalAlignment="Center"
+                                Content="{TemplateBinding Content}"
+                                ContentTemplate="{TemplateBinding ContentTemplate}"
+                                ContentTemplateSelector="{TemplateBinding ContentTemplateSelector}" />
+                            <TextBlock
+                                Margin="8,0,0,0"
+                                VerticalAlignment="Center"
+                                Foreground="{TemplateBinding Foreground}"
+                                Text="{TemplateBinding ToolTip}" />
+                        </StackPanel>
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsHighlighted" Value="True">
+                            <Setter TargetName="ItemBorder" Property="Background" Value="{StaticResource Teal}" />
+                            <Setter Property="Foreground" Value="White" />
+                        </Trigger>
+                        <Trigger Property="IsSelected" Value="True">
+                            <Setter TargetName="ItemBorder" Property="Background" Value="{StaticResource DarkTeal}" />
+                            <Setter Property="Foreground" Value="White" />
+                        </Trigger>
+                        <Trigger Property="IsEnabled" Value="False">
+                            <Setter Property="Foreground" Value="{DynamicResource TextFillColorDisabledBrush}" />
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+</ResourceDictionary>
diff --git a/Text-Grab/Styles/SelectionStyleComboBoxStyle.xaml b/Text-Grab/Styles/SelectionStyleComboBoxStyle.xaml
new file mode 100644
index 00000000..d16e7aeb
--- /dev/null
+++ b/Text-Grab/Styles/SelectionStyleComboBoxStyle.xaml
@@ -0,0 +1,106 @@
+<ResourceDictionary
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:wpfui="http://schemas.lepo.co/wpfui/2022/xaml">
+    <Style x:Key="SelectionStyleComboBoxStyle" TargetType="ComboBox">
+        <Setter Property="Background" Value="Transparent" />
+        <Setter Property="BorderBrush" Value="Transparent" />
+        <Setter Property="BorderThickness" Value="0" />
+        <Setter Property="FocusVisualStyle" Value="{x:Null}" />
+        <Setter Property="Foreground" Value="{wpfui:ThemeResource TextFillColorPrimaryBrush}" />
+        <Setter Property="HorizontalContentAlignment" Value="Center" />
+        <Setter Property="VerticalContentAlignment" Value="Center" />
+        <Setter Property="Padding" Value="0" />
+        <Setter Property="ScrollViewer.HorizontalScrollBarVisibility" Value="Disabled" />
+        <Setter Property="ScrollViewer.VerticalScrollBarVisibility" Value="Auto" />
+        <Setter Property="SnapsToDevicePixels" Value="True" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="ComboBox">
+                    <Grid SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}">
+                        <ToggleButton
+                            x:Name="SelectionButton"
+                            Width="Auto"
+                            Height="Auto"
+                            Margin="0"
+                            HorizontalAlignment="Stretch"
+                            VerticalAlignment="Stretch"
+                            Background="{TemplateBinding Background}"
+                            BorderBrush="{TemplateBinding BorderBrush}"
+                            BorderThickness="{TemplateBinding BorderThickness}"
+                            ClickMode="Press"
+                            Focusable="False"
+                            Foreground="{TemplateBinding Foreground}"
+                            IsChecked="{Binding IsDropDownOpen, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}">
+                            <ToggleButton.Template>
+                                <ControlTemplate TargetType="ToggleButton">
+                                    <Border
+                                        x:Name="SelectionButtonBorder"
+                                        Background="{TemplateBinding Background}"
+                                        CornerRadius="4"
+                                        SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}">
+                                        <ContentPresenter
+                                            HorizontalAlignment="Center"
+                                            VerticalAlignment="Center"
+                                            Content="{TemplateBinding Content}"
+                                            ContentTemplate="{TemplateBinding ContentTemplate}"
+                                            ContentTemplateSelector="{TemplateBinding ContentTemplateSelector}"
+                                            SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" />
+                                    </Border>
+                                </ControlTemplate>
+                            </ToggleButton.Template>
+                            <ContentPresenter
+                                HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
+                                VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
+                                Content="{Binding SelectionBoxItem, RelativeSource={RelativeSource TemplatedParent}}"
+                                ContentTemplate="{Binding SelectionBoxItemTemplate, RelativeSource={RelativeSource TemplatedParent}}"
+                                ContentTemplateSelector="{Binding ItemTemplateSelector, RelativeSource={RelativeSource TemplatedParent}}"
+                                IsHitTestVisible="False"
+                                SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" />
+                        </ToggleButton>
+                        <Popup
+                            x:Name="PART_Popup"
+                            AllowsTransparency="True"
+                            Focusable="False"
+                            IsOpen="{TemplateBinding IsDropDownOpen}"
+                            Placement="Bottom"
+                            PopupAnimation="Fade">
+                            <Border
+                                x:Name="DropDownBorder"
+                                MinWidth="{Binding ActualWidth, RelativeSource={RelativeSource TemplatedParent}}"
+                                Margin="0,4,0,0"
+                                Padding="4"
+                                Background="{DynamicResource ApplicationBackgroundBrush}"
+                                BorderBrush="{StaticResource Teal}"
+                                BorderThickness="1"
+                                CornerRadius="6">
+                                <ScrollViewer
+                                    MaxHeight="{TemplateBinding MaxDropDownHeight}"
+                                    CanContentScroll="True"
+                                    HorizontalScrollBarVisibility="{TemplateBinding ScrollViewer.HorizontalScrollBarVisibility}"
+                                    VerticalScrollBarVisibility="{TemplateBinding ScrollViewer.VerticalScrollBarVisibility}">
+                                    <ItemsPresenter KeyboardNavigation.DirectionalNavigation="Contained" />
+                                </ScrollViewer>
+                            </Border>
+                        </Popup>
+                    </Grid>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsMouseOver" Value="True">
+                            <Setter TargetName="SelectionButton" Property="Background" Value="{StaticResource Teal}" />
+                            <Setter TargetName="SelectionButton" Property="Foreground" Value="White" />
+                        </Trigger>
+                        <Trigger Property="IsDropDownOpen" Value="True">
+                            <Setter TargetName="SelectionButton" Property="Foreground" Value="White" />
+                        </Trigger>
+                        <Trigger Property="HasItems" Value="False">
+                            <Setter TargetName="DropDownBorder" Property="MinHeight" Value="34" />
+                        </Trigger>
+                        <Trigger Property="IsEnabled" Value="False">
+                            <Setter Property="Foreground" Value="{DynamicResource TextFillColorDisabledBrush}" />
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+</ResourceDictionary>
diff --git a/Text-Grab/Styles/TextStyles.xaml b/Text-Grab/Styles/TextStyles.xaml
index e05f30d3..56bd09d6 100644
--- a/Text-Grab/Styles/TextStyles.xaml
+++ b/Text-Grab/Styles/TextStyles.xaml
@@ -1,9 +1,17 @@
-<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
     <Style TargetType="TextBlock">
         <Setter Property="FontFamily" Value="Segoe UI" />
         <Setter Property="FontSize" Value="14" />
     </Style>
 
+    <Style x:Key="SymbolTextStyle" TargetType="TextBlock">
+        <Setter Property="HorizontalAlignment" Value="Center" />
+        <Setter Property="VerticalAlignment" Value="Center" />
+        <Setter Property="FontFamily" Value="Segoe MDL2 Assets" />
+        <Setter Property="FontSize" Value="16" />
+        <Setter Property="Margin" Value="4" />
+    </Style>
+
     <Style x:Key="TextBodyNormal" TargetType="TextBlock">
         <Setter Property="HorizontalAlignment" Value="Left" />
         <Setter Property="Padding" Value="0" />
@@ -17,4 +25,4 @@
         <Setter Property="FontWeight" Value="Bold" />
     </Style>
 
-</ResourceDictionary>
\ No newline at end of file
+</ResourceDictionary>
diff --git a/Text-Grab/Text-Grab.csproj b/Text-Grab/Text-Grab.csproj
index 0fe29466..23ed5387 100644
--- a/Text-Grab/Text-Grab.csproj
+++ b/Text-Grab/Text-Grab.csproj
@@ -52,17 +52,17 @@
 
     <ItemGroup>
         <PackageReference Include="CliWrap" Version="3.10.0" />
-        <PackageReference Include="Dapplo.Windows.User32" Version="2.0.15" />
+        <PackageReference Include="Dapplo.Windows.User32" Version="2.0.83" />
         <PackageReference Include="Humanizer.Core" Version="3.0.1" />
-        <PackageReference Include="Magick.NET-Q16-AnyCPU" Version="14.10.2" />
-        <PackageReference Include="Magick.NET.SystemDrawing" Version="8.0.15" />
-        <PackageReference Include="Magick.NET.SystemWindowsMedia" Version="8.0.15" />
+        <PackageReference Include="Magick.NET-Q16-AnyCPU" Version="14.10.3" />
+        <PackageReference Include="Magick.NET.SystemDrawing" Version="8.0.16" />
+        <PackageReference Include="Magick.NET.SystemWindowsMedia" Version="8.0.16" />
         <PackageReference Include="Microsoft.Toolkit.Uwp.Notifications" Version="7.1.3" />
-        <PackageReference Include="Microsoft.WindowsAppSDK.AI" Version="1.8.44" />
-        <PackageReference Include="Microsoft.WindowsAppSDK.Foundation" Version="1.8.251220000" />
-        <PackageReference Include="Microsoft.WindowsAppSDK.Runtime" Version="1.8.260101001" />
-        <PackageReference Include="Microsoft.WindowsAppSDK.WinUI" Version="1.8.251222000" />
-        <PackageReference Include="NCalcAsync" Version="5.11.0" />
+        <PackageReference Include="Microsoft.WindowsAppSDK.AI" Version="1.8.47" />
+        <PackageReference Include="Microsoft.WindowsAppSDK.Foundation" Version="1.8.260203002" />
+        <PackageReference Include="Microsoft.WindowsAppSDK.Runtime" Version="1.8.260209005" />
+        <PackageReference Include="Microsoft.WindowsAppSDK.WinUI" Version="1.8.260204000" />
+        <PackageReference Include="NCalcAsync" Version="5.12.0" />
         <PackageReference Include="UnitsNet" Version="5.75.0" />
         <PackageReference Include="WPF-UI" Version="4.2.0" />
         <PackageReference Include="WPF-UI.Tray" Version="4.2.0" />
diff --git a/Text-Grab/Themes/Generic.xaml b/Text-Grab/Themes/Generic.xaml
new file mode 100644
index 00000000..a3cdf84c
--- /dev/null
+++ b/Text-Grab/Themes/Generic.xaml
@@ -0,0 +1,122 @@
+<ResourceDictionary
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:controls="clr-namespace:Text_Grab.Controls"
+    xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml">
+
+    <!--  Inline chip embedded inside InlinePickerRichTextBox  -->
+    <Style TargetType="{x:Type controls:InlineChipElement}">
+        <Setter Property="Background" Value="#44308E98" />
+        <Setter Property="BorderBrush" Value="{DynamicResource Teal}" />
+        <Setter Property="BorderThickness" Value="1" />
+        <Setter Property="Foreground" Value="{DynamicResource TextFillColorPrimaryBrush}" />
+        <Setter Property="Padding" Value="6,1" />
+        <Setter Property="Margin" Value="1,0" />
+        <Setter Property="Cursor" Value="Arrow" />
+        <Setter Property="FocusVisualStyle" Value="{x:Null}" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type controls:InlineChipElement}">
+                    <Border
+                        x:Name="ChipBorder"
+                        Margin="{TemplateBinding Margin}"
+                        Background="{TemplateBinding Background}"
+                        BorderBrush="{TemplateBinding BorderBrush}"
+                        BorderThickness="{TemplateBinding BorderThickness}"
+                        CornerRadius="8"
+                        SnapsToDevicePixels="True">
+                        <StackPanel VerticalAlignment="Center" Orientation="Horizontal">
+                            <TextBlock
+                                Margin="{TemplateBinding Padding}"
+                                VerticalAlignment="Center"
+                                FontSize="11"
+                                Foreground="{TemplateBinding Foreground}"
+                                Text="{TemplateBinding DisplayName}" />
+                            <Button
+                                x:Name="PART_RemoveButton"
+                                Width="14"
+                                Height="14"
+                                Margin="0,0,3,0"
+                                VerticalAlignment="Center"
+                                Visibility="Collapsed">
+                                <Button.Style>
+                                    <Style TargetType="{x:Type Button}">
+                                        <Setter Property="Background" Value="Transparent" />
+                                        <Setter Property="BorderThickness" Value="0" />
+                                        <Setter Property="Padding" Value="1" />
+                                        <Setter Property="Cursor" Value="Hand" />
+                                        <Setter Property="Foreground" Value="{DynamicResource TextFillColorSecondaryBrush}" />
+                                        <Setter Property="Template">
+                                            <Setter.Value>
+                                                <ControlTemplate TargetType="{x:Type Button}">
+                                                    <Border
+                                                        x:Name="Bg"
+                                                        Padding="{TemplateBinding Padding}"
+                                                        Background="{TemplateBinding Background}"
+                                                        CornerRadius="7">
+                                                        <ContentPresenter HorizontalAlignment="Center" VerticalAlignment="Center" />
+                                                    </Border>
+                                                    <ControlTemplate.Triggers>
+                                                        <Trigger Property="IsMouseOver" Value="True">
+                                                            <Setter TargetName="Bg" Property="Background" Value="{DynamicResource ControlStrongFillColorDefaultBrush}" />
+                                                            <Setter Property="Foreground" Value="{DynamicResource TextFillColorPrimaryBrush}" />
+                                                        </Trigger>
+                                                    </ControlTemplate.Triggers>
+                                                </ControlTemplate>
+                                            </Setter.Value>
+                                        </Setter>
+                                    </Style>
+                                </Button.Style>
+                                <ui:SymbolIcon FontSize="8" Symbol="Dismiss24" />
+                            </Button>
+                        </StackPanel>
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsMouseOver" Value="True">
+                            <Setter TargetName="ChipBorder" Property="Background" Value="#66308E98" />
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <!--  InlinePickerRichTextBox outer container style  -->
+    <Style TargetType="{x:Type controls:InlinePickerRichTextBox}">
+        <Setter Property="Background" Value="{DynamicResource ControlFillColorDefaultBrush}" />
+        <Setter Property="BorderBrush" Value="{DynamicResource ControlStrokeColorDefaultBrush}" />
+        <Setter Property="BorderThickness" Value="1" />
+        <Setter Property="Foreground" Value="{DynamicResource TextFillColorPrimaryBrush}" />
+        <Setter Property="Padding" Value="6,4" />
+        <Setter Property="MinHeight" Value="28" />
+        <Setter Property="SelectionBrush" Value="{DynamicResource ControlStrongFillColorDefaultBrush}" />
+        <Setter Property="CaretBrush" Value="{DynamicResource TextFillColorPrimaryBrush}" />
+        <Setter Property="VerticalContentAlignment" Value="Center" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type controls:InlinePickerRichTextBox}">
+                    <Border
+                        x:Name="PART_Border"
+                        Background="{TemplateBinding Background}"
+                        BorderBrush="{TemplateBinding BorderBrush}"
+                        BorderThickness="{TemplateBinding BorderThickness}"
+                        CornerRadius="4"
+                        SnapsToDevicePixels="True">
+                        <ScrollViewer
+                            x:Name="PART_ContentHost"
+                            Padding="{TemplateBinding Padding}"
+                            Focusable="False"
+                            HorizontalScrollBarVisibility="Hidden"
+                            VerticalScrollBarVisibility="Hidden" />
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsKeyboardFocusWithin" Value="True">
+                            <Setter TargetName="PART_Border" Property="BorderBrush" Value="{DynamicResource Teal}" />
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+</ResourceDictionary>
diff --git a/Text-Grab/Utilities/BarcodeUtilities.cs b/Text-Grab/Utilities/BarcodeUtilities.cs
index 40385f79..e0e9ebe0 100644
--- a/Text-Grab/Utilities/BarcodeUtilities.cs
+++ b/Text-Grab/Utilities/BarcodeUtilities.cs
@@ -1,4 +1,7 @@
+using System;
+using System.Diagnostics;
 using System.Drawing;
+using System.Runtime.InteropServices;
 using Text_Grab.Models;
 using ZXing;
 using ZXing.Common;
@@ -11,16 +14,40 @@ namespace Text_Grab.Utilities;
 
 public static class BarcodeUtilities
 {
+    private static OcrOutput EmptyBarcodeOutput => new() { Kind = OcrOutputKind.Barcode, RawOutput = string.Empty };
 
     public static OcrOutput TryToReadBarcodes(Bitmap bitmap)
     {
+        if (!CanReadBitmapDimensions(bitmap))
+            return EmptyBarcodeOutput;
+
         BarcodeReader barcodeReader = new()
         {
             AutoRotate = true,
-            Options = new ZXing.Common.DecodingOptions { TryHarder = true }
+            Options = new DecodingOptions { TryHarder = true }
         };
 
-        ZXing.Result result = barcodeReader.Decode(bitmap);
+        Result? result = null;
+
+        try
+        {
+            result = barcodeReader.Decode(bitmap);
+        }
+        catch (ArgumentException ex)
+        {
+            Debug.WriteLine($"Unable to decode barcode from bitmap: {ex.Message}");
+            return EmptyBarcodeOutput;
+        }
+        catch (ObjectDisposedException ex)
+        {
+            Debug.WriteLine($"Unable to decode barcode from disposed bitmap: {ex.Message}");
+            return EmptyBarcodeOutput;
+        }
+        catch (ExternalException ex)
+        {
+            Debug.WriteLine($"Unable to decode barcode from GDI+ bitmap: {ex.Message}");
+            return EmptyBarcodeOutput;
+        }
 
         string resultString = string.Empty;
         if (result is not null)
@@ -34,11 +61,39 @@ public static OcrOutput TryToReadBarcodes(Bitmap bitmap)
         };
     }
 
+    private static bool CanReadBitmapDimensions(Bitmap? bitmap)
+    {
+        if (bitmap is null)
+            return false;
+
+        try
+        {
+            return bitmap.Width > 0 && bitmap.Height > 0;
+        }
+        catch (ArgumentException ex)
+        {
+            Debug.WriteLine($"Unable to read bitmap dimensions for barcode scanning: {ex.Message}");
+            return false;
+        }
+        catch (ObjectDisposedException ex)
+        {
+            Debug.WriteLine($"Unable to read bitmap dimensions for disposed barcode bitmap: {ex.Message}");
+            return false;
+        }
+        catch (ExternalException ex)
+        {
+            Debug.WriteLine($"Unable to read barcode bitmap dimensions due to GDI+ error: {ex.Message}");
+            return false;
+        }
+    }
+
     public static Bitmap GetQrCodeForText(string text, ErrorCorrectionLevel correctionLevel)
     {
-        BitmapRenderer bitmapRenderer = new();
-        bitmapRenderer.Foreground = System.Drawing.Color.Black;
-        bitmapRenderer.Background = System.Drawing.Color.White;
+        BitmapRenderer bitmapRenderer = new()
+        {
+            Foreground = System.Drawing.Color.Black,
+            Background = System.Drawing.Color.White
+        };
 
         BarcodeWriter barcodeWriter = new()
         {
@@ -81,4 +136,4 @@ public static SvgImage GetSvgQrCodeForText(string text, ErrorCorrectionLevel cor
 
         return svg;
     }
-}
\ No newline at end of file
+}
diff --git a/Text-Grab/Utilities/FreeformCaptureUtilities.cs b/Text-Grab/Utilities/FreeformCaptureUtilities.cs
new file mode 100644
index 00000000..02383864
--- /dev/null
+++ b/Text-Grab/Utilities/FreeformCaptureUtilities.cs
@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Linq;
+using System.Windows;
+using System.Windows.Media;
+using Point = System.Windows.Point;
+
+namespace Text_Grab.Utilities;
+
+public static class FreeformCaptureUtilities
+{
+    public static Rect GetBounds(IReadOnlyList<Point> points)
+    {
+        if (points is null || points.Count == 0)
+            return Rect.Empty;
+
+        double left = points.Min(static point => point.X);
+        double top = points.Min(static point => point.Y);
+        double right = points.Max(static point => point.X);
+        double bottom = points.Max(static point => point.Y);
+
+        return new Rect(
+            new Point(Math.Floor(left), Math.Floor(top)),
+            new Point(Math.Ceiling(right), Math.Ceiling(bottom)));
+    }
+
+    public static PathGeometry BuildGeometry(IReadOnlyList<Point> points)
+    {
+        PathGeometry geometry = new();
+        if (points is null || points.Count < 2)
+            return geometry;
+
+        PathFigure figure = new()
+        {
+            StartPoint = points[0],
+            IsClosed = true,
+            IsFilled = true
+        };
+
+        foreach (Point point in points.Skip(1))
+            figure.Segments.Add(new LineSegment(point, true));
+
+        geometry.Figures.Add(figure);
+        geometry.Freeze();
+        return geometry;
+    }
+
+    public static Bitmap CreateMaskedBitmap(Bitmap sourceBitmap, IReadOnlyList<Point> pointsRelativeToBounds)
+    {
+        ArgumentNullException.ThrowIfNull(sourceBitmap);
+
+        if (pointsRelativeToBounds is null || pointsRelativeToBounds.Count < 3)
+            return new Bitmap(sourceBitmap);
+
+        Bitmap maskedBitmap = new(sourceBitmap.Width, sourceBitmap.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
+        using Graphics graphics = Graphics.FromImage(maskedBitmap);
+        using GraphicsPath graphicsPath = new();
+
+        graphics.SmoothingMode = SmoothingMode.AntiAlias;
+        graphics.Clear(System.Drawing.Color.Gray);
+
+        graphicsPath.AddPolygon([.. pointsRelativeToBounds.Select(static point => new PointF((float)point.X, (float)point.Y))]);
+        graphics.SetClip(graphicsPath);
+        graphics.DrawImage(sourceBitmap, new Rectangle(0, 0, sourceBitmap.Width, sourceBitmap.Height));
+
+        return maskedBitmap;
+    }
+}
diff --git a/Text-Grab/Utilities/GrabTemplateExecutor.cs b/Text-Grab/Utilities/GrabTemplateExecutor.cs
new file mode 100644
index 00000000..52ead768
--- /dev/null
+++ b/Text-Grab/Utilities/GrabTemplateExecutor.cs
@@ -0,0 +1,411 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using System.Windows;
+using Text_Grab.Interfaces;
+using Text_Grab.Models;
+
+namespace Text_Grab.Utilities;
+
+/// <summary>
+/// Executes a <see cref="GrabTemplate"/> against a captured screen region:
+/// OCRs each sub-region, then formats the results using the template's
+/// <see cref="GrabTemplate.OutputTemplate"/> string.
+///
+/// Output template syntax — region placeholders:
+///   {N}        — OCR text from region N  (1-based)
+///   {N:trim}   — trimmed OCR text
+///   {N:upper}  — uppercased OCR text
+///   {N:lower}  — lowercased OCR text
+///
+/// Output template syntax — pattern placeholders:
+///   {p:Name:first}     — first regex match
+///   {p:Name:last}      — last regex match
+///   {p:Name:all:, }    — all matches joined by separator
+///   {p:Name:2}         — 2nd match (1-based)
+///   {p:Name:1,3}       — 1st and 3rd matches joined by separator
+///
+/// Escape sequences:
+///   \n         — newline
+///   \t         — tab
+///   \\         — literal backslash
+///   \{         — literal opening brace
+/// </summary>
+public static class GrabTemplateExecutor
+{
+    // Matches {N} or {N:modifier} where N is one or more digits
+    private static readonly Regex PlaceholderRegex =
+        new(@"\{(\d+)(?::([a-z]+))?\}", RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+    // Matches {p:PatternName:mode} or {p:PatternName:mode:separator}
+    // Group 1 = pattern name, Group 2 = match mode, Group 3 = optional separator
+    private static readonly Regex PatternPlaceholderRegex =
+        new(@"\{p:([^:}]+):([^:}]+)(?::([^}]*))?\}", RegexOptions.Compiled);
+
+    private static readonly TimeSpan RegexTimeout = TimeSpan.FromSeconds(5);
+
+    // ── Public API ────────────────────────────────────────────────────────────
+
+    /// <summary>
+    /// Executes the given template using <paramref name="captureRegion"/> as the
+    /// coordinate space. Each template region is mapped to a sub-rectangle of
+    /// <paramref name="captureRegion"/>, OCR'd, then assembled via the output template.
+    /// </summary>
+    /// <param name="template">The template to execute.</param>
+    /// <param name="captureRegion">
+    ///     The screen rectangle in physical screen pixels that bounds the user's
+    ///     selection. Template region ratios are applied to this rectangle's
+    ///     width/height to derive each sub-region's capture bounds.
+    /// </param>
+    /// <param name="language">The OCR language to use. Pass null to use the app default.</param>
+    public static async Task<string> ExecuteTemplateAsync(
+        GrabTemplate template,
+        Rect captureRegion,
+        ILanguage? language = null)
+    {
+        if (!template.IsValid)
+            return string.Empty;
+
+        ILanguage resolvedLanguage = language ?? LanguageUtilities.GetOCRLanguage();
+
+        // 1. OCR each region (if any)
+        Dictionary<int, string> regionResults = template.Regions.Count > 0
+            ? await OcrAllRegionsAsync(template, captureRegion, resolvedLanguage)
+            : [];
+
+        // 2. OCR full capture area for pattern matching (if any pattern references exist)
+        string? fullAreaText = null;
+        if (template.PatternMatches.Count > 0)
+        {
+            try
+            {
+                fullAreaText = await OcrUtilities.GetTextFromAbsoluteRectAsync(captureRegion, resolvedLanguage);
+            }
+            catch (Exception)
+            {
+                fullAreaText = string.Empty;
+            }
+        }
+
+        // 3. Resolve pattern regexes from saved patterns
+        Dictionary<string, string> patternRegexes = [];
+        if (template.PatternMatches.Count > 0)
+            patternRegexes = ResolvePatternRegexes(template.PatternMatches);
+
+        // 4. Apply output template
+        string output = ApplyOutputTemplate(template.OutputTemplate, regionResults);
+
+        if (fullAreaText != null)
+            output = ApplyPatternPlaceholders(output, fullAreaText, template.PatternMatches, patternRegexes);
+
+        return output;
+    }
+
+    /// <summary>
+    /// Applies the output template string with the provided region text values.
+    /// Useful for unit testing the string processing independently of OCR.
+    /// </summary>
+    public static string ApplyOutputTemplate(
+        string outputTemplate,
+        IReadOnlyDictionary<int, string> regionResults)
+    {
+        if (string.IsNullOrEmpty(outputTemplate))
+            return string.Empty;
+
+        // Replace escape sequences first
+        string processed = outputTemplate
+            .Replace(@"\\", "\x00BACKSLASH\x00")  // protect real backslashes
+            .Replace(@"\n", "\n")
+            .Replace(@"\t", "\t")
+            .Replace(@"\{", "\x00LBRACE\x00")     // protect literal braces
+            .Replace("\x00BACKSLASH\x00", @"\");
+
+        // Replace {N} / {N:modifier} placeholders
+        string result = PlaceholderRegex.Replace(processed, match =>
+        {
+            if (!int.TryParse(match.Groups[1].Value, out int regionNumber))
+                return match.Value; // leave unknown placeholders as-is
+
+            regionResults.TryGetValue(regionNumber, out string? text);
+            text ??= string.Empty;
+
+            string modifier = match.Groups[2].Success
+                ? match.Groups[2].Value.ToLowerInvariant()
+                : string.Empty;
+
+            return modifier switch
+            {
+                "trim" => text.Trim(),
+                "upper" => text.ToUpper(),
+                "lower" => text.ToLower(),
+                _ => text
+            };
+        });
+
+        // Restore protected literal characters
+        result = result.Replace("\x00LBRACE\x00", "{");
+
+        return result;
+    }
+
+    // ── Pattern placeholder processing ──────────────────────────────────────
+
+    /// <summary>
+    /// Replaces <c>{p:PatternName:mode}</c> and <c>{p:PatternName:mode:separator}</c>
+    /// placeholders in the template with regex match results from the full-area OCR text.
+    /// </summary>
+    public static string ApplyPatternPlaceholders(
+        string template,
+        string fullText,
+        IReadOnlyList<TemplatePatternMatch> patternMatches,
+        IReadOnlyDictionary<string, string> patternRegexes)
+    {
+        if (string.IsNullOrEmpty(template) || patternMatches.Count == 0)
+            return template;
+
+        return PatternPlaceholderRegex.Replace(template, match =>
+        {
+            string patternName = match.Groups[1].Value;
+            string mode = match.Groups[2].Value;
+            string separatorOverride = match.Groups[3].Success ? match.Groups[3].Value : null!;
+
+            // Find the matching pattern config
+            TemplatePatternMatch? patternMatch = patternMatches
+                .FirstOrDefault(p => p.PatternName.Equals(patternName, StringComparison.OrdinalIgnoreCase));
+
+            if (patternMatch == null)
+                return match.Value; // leave unresolved
+
+            // Resolve the regex string
+            if (!patternRegexes.TryGetValue(patternMatch.PatternId, out string? regexPattern)
+                && !patternRegexes.TryGetValue(patternMatch.PatternName, out regexPattern))
+                return string.Empty; // pattern not found
+
+            string separator = separatorOverride ?? patternMatch.Separator;
+
+            try
+            {
+                MatchCollection regexMatches = Regex.Matches(fullText, regexPattern, RegexOptions.Multiline, RegexTimeout);
+
+                if (regexMatches.Count == 0)
+                    return string.Empty;
+
+                return ExtractMatchesByMode(regexMatches, mode, separator);
+            }
+            catch (RegexMatchTimeoutException)
+            {
+                return string.Empty;
+            }
+            catch (ArgumentException)
+            {
+                return string.Empty; // invalid regex
+            }
+        });
+    }
+
+    /// <summary>
+    /// Extracts match values based on the mode string.
+    /// </summary>
+    internal static string ExtractMatchesByMode(MatchCollection matches, string mode, string separator)
+    {
+        List<string> allValues = matches.Select(m => m.Value).ToList();
+
+        return mode.ToLowerInvariant() switch
+        {
+            "first" => allValues[0],
+            "last" => allValues[^1],
+            "all" => string.Join(separator, allValues),
+            _ => ExtractByIndices(allValues, mode, separator)
+        };
+    }
+
+    private static string ExtractByIndices(List<string> values, string mode, string separator)
+    {
+        // mode is either a single index like "2" or comma-separated like "1,3,5"
+        string[] parts = mode.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        List<string> selected = [];
+
+        foreach (string part in parts)
+        {
+            if (int.TryParse(part, out int index) && index >= 1 && index <= values.Count)
+                selected.Add(values[index - 1]); // convert 1-based to 0-based
+        }
+
+        return string.Join(separator, selected);
+    }
+
+    /// <summary>
+    /// Resolves <see cref="TemplatePatternMatch"/> entries to their actual regex strings
+    /// by loading saved <see cref="StoredRegex"/> patterns from settings.
+    /// Returns a dictionary keyed by both PatternId and PatternName for flexible lookup.
+    /// </summary>
+    internal static Dictionary<string, string> ResolvePatternRegexes(
+        IReadOnlyList<TemplatePatternMatch> patternMatches)
+    {
+        Dictionary<string, string> result = [];
+
+        StoredRegex[] savedPatterns = LoadSavedPatterns();
+        Dictionary<string, StoredRegex> byId = [];
+        Dictionary<string, StoredRegex> byName = new(StringComparer.OrdinalIgnoreCase);
+
+        foreach (StoredRegex sr in savedPatterns)
+        {
+            byId[sr.Id] = sr;
+            byName[sr.Name] = sr;
+        }
+
+        foreach (TemplatePatternMatch pm in patternMatches)
+        {
+            StoredRegex? resolved = null;
+
+            // Prefer lookup by ID (survives renames)
+            if (!string.IsNullOrEmpty(pm.PatternId) && byId.TryGetValue(pm.PatternId, out resolved))
+            {
+                result[pm.PatternId] = resolved.Pattern;
+                result[pm.PatternName] = resolved.Pattern;
+                continue;
+            }
+
+            // Fallback to name
+            if (byName.TryGetValue(pm.PatternName, out resolved))
+            {
+                result[pm.PatternId] = resolved.Pattern;
+                result[pm.PatternName] = resolved.Pattern;
+            }
+        }
+
+        return result;
+    }
+
+    private static StoredRegex[] LoadSavedPatterns()
+    {
+        try
+        {
+            string json = Properties.Settings.Default.RegexList;
+            if (string.IsNullOrWhiteSpace(json))
+                return StoredRegex.GetDefaultPatterns();
+
+            return JsonSerializer.Deserialize<StoredRegex[]>(json) ?? StoredRegex.GetDefaultPatterns();
+        }
+        catch
+        {
+            return StoredRegex.GetDefaultPatterns();
+        }
+    }
+
+    // ── Private helpers ───────────────────────────────────────────────────────
+
+    private static async Task<Dictionary<int, string>> OcrAllRegionsAsync(
+        GrabTemplate template,
+        Rect captureRegion,
+        ILanguage language)
+    {
+        Dictionary<int, string> results = [];
+
+        foreach (TemplateRegion region in template.Regions)
+        {
+            // Compute absolute screen rect from capture region + region ratios
+            Rect absoluteRegionRect = new(
+                x: captureRegion.X + region.RatioLeft * captureRegion.Width,
+                y: captureRegion.Y + region.RatioTop * captureRegion.Height,
+                width: region.RatioWidth * captureRegion.Width,
+                height: region.RatioHeight * captureRegion.Height);
+
+            if (absoluteRegionRect.Width <= 0 || absoluteRegionRect.Height <= 0)
+            {
+                results[region.RegionNumber] = region.DefaultValue;
+                continue;
+            }
+
+            try
+            {
+                // GetTextFromAbsoluteRectAsync uses absolute screen coordinates
+                string regionText = await OcrUtilities.GetTextFromAbsoluteRectAsync(absoluteRegionRect, language);
+                // Use default value when OCR returns nothing
+                results[region.RegionNumber] = string.IsNullOrWhiteSpace(regionText)
+                    ? region.DefaultValue
+                    : regionText.Trim();
+            }
+            catch (Exception)
+            {
+                results[region.RegionNumber] = region.DefaultValue;
+            }
+        }
+
+        return results;
+    }
+
+    /// <summary>
+    /// Validates the output template syntax and returns a list of issues.
+    /// Returns an empty list when valid.
+    /// </summary>
+    public static List<string> ValidateOutputTemplate(
+        string outputTemplate,
+        IEnumerable<int> availableRegionNumbers,
+        IEnumerable<string>? availablePatternNames = null)
+    {
+        List<string> issues = [];
+        HashSet<int> available = [.. availableRegionNumbers];
+
+        // Validate region placeholders
+        MatchCollection regionMatches = PlaceholderRegex.Matches(outputTemplate);
+        HashSet<int> referenced = [];
+
+        foreach (Match match in regionMatches)
+        {
+            if (!int.TryParse(match.Groups[1].Value, out int num))
+            {
+                issues.Add($"Invalid placeholder: {match.Value}");
+                continue;
+            }
+
+            if (!available.Contains(num))
+                issues.Add($"Placeholder {{{num}}} references region {num} which does not exist.");
+
+            referenced.Add(num);
+        }
+
+        foreach (int availableNum in available)
+        {
+            if (!referenced.Contains(availableNum))
+                issues.Add($"Region {availableNum} is defined but not used in the output template.");
+        }
+
+        // Validate pattern placeholders
+        if (availablePatternNames != null)
+        {
+            HashSet<string> availableNames = new(availablePatternNames, StringComparer.OrdinalIgnoreCase);
+            MatchCollection patternMatches = PatternPlaceholderRegex.Matches(outputTemplate);
+
+            foreach (Match match in patternMatches)
+            {
+                string patternName = match.Groups[1].Value;
+                string mode = match.Groups[2].Value;
+
+                if (!availableNames.Contains(patternName))
+                    issues.Add($"Pattern placeholder references \"{patternName}\" which is not a saved pattern.");
+
+                if (!IsValidMatchMode(mode))
+                    issues.Add($"Invalid match mode \"{mode}\" for pattern \"{patternName}\". Use first, last, all, or numeric indices.");
+            }
+        }
+
+        return issues;
+    }
+
+    private static bool IsValidMatchMode(string mode)
+    {
+        if (string.IsNullOrEmpty(mode))
+            return false;
+
+        return mode.ToLowerInvariant() switch
+        {
+            "first" or "last" or "all" => true,
+            _ => mode.Split(',', StringSplitOptions.RemoveEmptyEntries)
+                     .All(p => int.TryParse(p.Trim(), out int v) && v >= 1)
+        };
+    }
+}
diff --git a/Text-Grab/Utilities/GrabTemplateManager.cs b/Text-Grab/Utilities/GrabTemplateManager.cs
new file mode 100644
index 00000000..2c45ad8d
--- /dev/null
+++ b/Text-Grab/Utilities/GrabTemplateManager.cs
@@ -0,0 +1,282 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Windows.Media.Imaging;
+using Text_Grab.Models;
+using Text_Grab.Properties;
+using Wpf.Ui.Controls;
+
+namespace Text_Grab.Utilities;
+
+/// <summary>
+/// Provides CRUD operations for <see cref="GrabTemplate"/> objects, persisted as
+/// a JSON file on disk. Previously stored in application settings, but moved to
+/// file-based storage because ApplicationDataContainer has an 8 KB per-value limit.
+/// Pattern follows <see cref="PostGrabActionManager"/>.
+/// </summary>
+public static class GrabTemplateManager
+{
+    private static readonly Settings DefaultSettings = AppUtilities.TextGrabSettings;
+
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        WriteIndented = true,
+        PropertyNameCaseInsensitive = true,
+    };
+
+    private const string TemplatesFileName = "GrabTemplates.json";
+    private static bool _migrated;
+
+    // Allow tests to override the file path
+    internal static string? TestFilePath { get; set; }
+
+    // ── File path ─────────────────────────────────────────────────────────────
+
+    private static string GetTemplatesFilePath()
+    {
+        if (TestFilePath is not null)
+            return TestFilePath;
+
+        if (AppUtilities.IsPackaged())
+        {
+            string localFolder = Windows.Storage.ApplicationData.Current.LocalFolder.Path;
+            return Path.Combine(localFolder, TemplatesFileName);
+        }
+
+        string? exeDir = Path.GetDirectoryName(FileUtilities.GetExePath());
+        return Path.Combine(exeDir ?? "c:\\Text-Grab", TemplatesFileName);
+    }
+
+    /// <summary>
+    /// Saves <paramref name="imageSource"/> as a PNG in the template-images folder, named
+    /// after <paramref name="templateName"/> and the first 8 characters of <paramref name="templateId"/>.
+    /// Returns the full file path on success, or <c>null</c> if the source is null or the write fails.
+    /// </summary>
+    public static string? SaveTemplateReferenceImage(BitmapSource? imageSource, string templateName, string templateId)
+    {
+        if (imageSource is null)
+            return null;
+
+        try
+        {
+            string folder = GetTemplateImagesFolder();
+            if (!Directory.Exists(folder))
+                Directory.CreateDirectory(folder);
+
+            string safeName = templateName.ReplaceReservedCharacters();
+            string shortId = templateId.Length >= 8 ? templateId[..8] : templateId;
+            string filePath = Path.Combine(folder, $"{safeName}_{shortId}.png");
+
+            // Write to a temp file first so the encoder never contends with WPF's
+            // read lock on filePath (held when BitmapImage was loaded without OnLoad).
+            string tempPath = Path.Combine(folder, $"{Guid.NewGuid():N}.tmp");
+
+            PngBitmapEncoder encoder = new();
+            encoder.Frames.Add(BitmapFrame.Create(imageSource));
+            using (FileStream fs = new(tempPath, FileMode.Create, FileAccess.Write, FileShare.None))
+                encoder.Save(fs);
+
+            // Atomically replace the destination; succeeds even when the target file
+            // is open for reading by another process (e.g. WPF's BitmapImage).
+            File.Move(tempPath, filePath, overwrite: true);
+            return filePath;
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Failed to save template reference image: {ex.Message}");
+            return null;
+        }
+    }
+
+    /// <summary>Returns the folder where template reference images are stored alongside the templates JSON.</summary>
+    public static string GetTemplateImagesFolder()
+    {
+        if (AppUtilities.IsPackaged())
+        {
+            string localFolder = Windows.Storage.ApplicationData.Current.LocalFolder.Path;
+            return Path.Combine(localFolder, "template-images");
+        }
+
+        string? exeDir = Path.GetDirectoryName(FileUtilities.GetExePath());
+        return Path.Combine(exeDir ?? "c:\\Text-Grab", "template-images");
+    }
+
+    // ── Migration from settings ───────────────────────────────────────────────
+
+    private static void MigrateFromSettingsIfNeeded()
+    {
+        if (_migrated)
+            return;
+
+        _migrated = true;
+
+        string filePath = GetTemplatesFilePath();
+        if (File.Exists(filePath))
+            return;
+
+        try
+        {
+            string settingsJson = DefaultSettings.GrabTemplatesJSON;
+            if (string.IsNullOrWhiteSpace(settingsJson))
+                return;
+
+            // Validate the JSON before migrating
+            List<GrabTemplate>? templates = JsonSerializer.Deserialize<List<GrabTemplate>>(settingsJson, JsonOptions);
+            if (templates is null || templates.Count == 0)
+                return;
+
+            string? dir = Path.GetDirectoryName(filePath);
+            if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
+                Directory.CreateDirectory(dir);
+
+            File.WriteAllText(filePath, settingsJson);
+
+            // Clear the setting so it no longer overflows the container
+            DefaultSettings.GrabTemplatesJSON = string.Empty;
+            DefaultSettings.Save();
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Failed to migrate GrabTemplates from settings to file: {ex.Message}");
+        }
+    }
+
+    // ── Read ──────────────────────────────────────────────────────────────────
+
+    /// <summary>Returns all saved templates, or an empty list if none exist.</summary>
+    public static List<GrabTemplate> GetAllTemplates()
+    {
+        MigrateFromSettingsIfNeeded();
+
+        string filePath = GetTemplatesFilePath();
+
+        if (!File.Exists(filePath))
+            return [];
+
+        try
+        {
+            string json = File.ReadAllText(filePath);
+
+            if (string.IsNullOrWhiteSpace(json))
+                return [];
+
+            List<GrabTemplate>? templates = JsonSerializer.Deserialize<List<GrabTemplate>>(json, JsonOptions);
+            if (templates is not null)
+                return templates;
+        }
+        catch (JsonException)
+        {
+            // Return empty list if deserialization fails — never crash
+        }
+        catch (IOException ex)
+        {
+            Debug.WriteLine($"Failed to read GrabTemplates file: {ex.Message}");
+        }
+
+        return [];
+    }
+
+    /// <summary>Returns the template with the given ID, or null.</summary>
+    public static GrabTemplate? GetTemplateById(string id)
+    {
+        if (string.IsNullOrWhiteSpace(id))
+            return null;
+
+        return GetAllTemplates().FirstOrDefault(t => t.Id == id);
+    }
+
+    // ── Write ─────────────────────────────────────────────────────────────────
+
+    /// <summary>Replaces the entire saved template list.</summary>
+    public static void SaveTemplates(List<GrabTemplate> templates)
+    {
+        string json = JsonSerializer.Serialize(templates, JsonOptions);
+        string filePath = GetTemplatesFilePath();
+
+        string? dir = Path.GetDirectoryName(filePath);
+        if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
+            Directory.CreateDirectory(dir);
+
+        File.WriteAllText(filePath, json);
+    }
+
+    /// <summary>Adds a new template (or updates an existing one with the same ID).</summary>
+    public static void AddOrUpdateTemplate(GrabTemplate template)
+    {
+        List<GrabTemplate> templates = GetAllTemplates();
+        int existing = templates.FindIndex(t => t.Id == template.Id);
+        if (existing >= 0)
+            templates[existing] = template;
+        else
+            templates.Add(template);
+
+        SaveTemplates(templates);
+    }
+
+    /// <summary>Removes the template with the given ID. No-op if not found.</summary>
+    public static void DeleteTemplate(string id)
+    {
+        List<GrabTemplate> templates = GetAllTemplates();
+        int removed = templates.RemoveAll(t => t.Id == id);
+        if (removed > 0)
+            SaveTemplates(templates);
+    }
+
+    /// <summary>Creates and saves a shallow copy of an existing template with a new ID and name.</summary>
+    public static GrabTemplate? DuplicateTemplate(string id)
+    {
+        GrabTemplate? original = GetTemplateById(id);
+        if (original is null)
+            return null;
+
+        string json = JsonSerializer.Serialize(original, JsonOptions);
+        GrabTemplate? copy = JsonSerializer.Deserialize<GrabTemplate>(json, JsonOptions);
+        if (copy is null)
+            return null;
+
+        copy.Id = Guid.NewGuid().ToString();
+        copy.Name = $"{original.Name} (copy)";
+        copy.CreatedDate = DateTimeOffset.Now;
+        copy.LastUsedDate = null;
+
+        AddOrUpdateTemplate(copy);
+        return copy;
+    }
+
+    // ── ButtonInfo bridge ─────────────────────────────────────────────────────
+
+    /// <summary>
+    /// Generates a <see cref="ButtonInfo"/> post-grab action that executes the given template.
+    /// </summary>
+    public static ButtonInfo CreateButtonInfoForTemplate(GrabTemplate template)
+    {
+        return new ButtonInfo(
+            buttonText: template.Name,
+            clickEvent: "ApplyTemplate_Click",
+            symbolIcon: SymbolRegular.DocumentTableSearch24,
+            defaultCheckState: DefaultCheckState.Off)
+        {
+            TemplateId = template.Id,
+            IsRelevantForFullscreenGrab = true,
+            IsRelevantForEditWindow = false,
+            OrderNumber = 7.0,
+        };
+    }
+
+    /// <summary>
+    /// Updates a <see cref="GrabTemplate"/>'s LastUsedDate and persists it.
+    /// </summary>
+    public static void RecordUsage(string templateId)
+    {
+        List<GrabTemplate> templates = GetAllTemplates();
+        GrabTemplate? template = templates.FirstOrDefault(t => t.Id == templateId);
+        if (template is null)
+            return;
+
+        template.LastUsedDate = DateTimeOffset.Now;
+        SaveTemplates(templates);
+    }
+}
diff --git a/Text-Grab/Utilities/ImageMethods.cs b/Text-Grab/Utilities/ImageMethods.cs
index ae43afd5..831b5b21 100644
--- a/Text-Grab/Utilities/ImageMethods.cs
+++ b/Text-Grab/Utilities/ImageMethods.cs
@@ -90,7 +90,7 @@ public static BitmapImage CachedBitmapToBitmapImage(System.Windows.Media.Imaging
         return bitmapImage;
     }
 
-    public static Bitmap GetRegionOfScreenAsBitmap(Rectangle region)
+    public static Bitmap GetRegionOfScreenAsBitmap(Rectangle region, bool cacheResult = true)
     {
         Bitmap bmp = new(region.Width, region.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
         using Graphics g = Graphics.FromImage(bmp);
@@ -98,7 +98,9 @@ public static Bitmap GetRegionOfScreenAsBitmap(Rectangle region)
         g.CopyFromScreen(region.Left, region.Top, 0, 0, bmp.Size, CopyPixelOperation.SourceCopy);
         bmp = PadImage(bmp);
 
-        Singleton<HistoryService>.Instance.CacheLastBitmap(bmp);
+        if (cacheResult)
+            Singleton<HistoryService>.Instance.CacheLastBitmap(bmp);
+
         return bmp;
     }
 
@@ -117,16 +119,16 @@ public static Bitmap GetWindowsBoundsBitmap(Window passedWindow)
         {
             Rect imageRect = grabFrame.GetImageContentRect();
 
-            int borderThickness = 2;
-            int titleBarHeight = 32;
-            int bottomBarHeight = 42;
-
             if (imageRect == Rect.Empty)
             {
-                thisCorrectedLeft = (int)((absPosPoint.X + borderThickness) * dpi.DpiScaleX);
-                thisCorrectedTop = (int)((absPosPoint.Y + (titleBarHeight + borderThickness)) * dpi.DpiScaleY);
-                windowWidth -= (int)((2 * borderThickness) * dpi.DpiScaleX);
-                windowHeight -= (int)((titleBarHeight + bottomBarHeight + (2 * borderThickness)) * dpi.DpiScaleY);
+                // Ask WPF's layout engine for the exact physical-pixel bounds of the
+                // transparent content area. This is always correct regardless of DPI,
+                // border thickness, or title/bottom bar heights.
+                Rectangle contentRect = grabFrame.GetContentAreaScreenRect();
+                thisCorrectedLeft = contentRect.X;
+                thisCorrectedTop = contentRect.Y;
+                windowWidth = contentRect.Width;
+                windowHeight = contentRect.Height;
             }
             else
             {
@@ -218,8 +220,12 @@ public static Bitmap BitmapSourceToBitmap(BitmapSource source)
 
     public static Bitmap GetBitmapFromIRandomAccessStream(IRandomAccessStream stream)
     {
-        Bitmap bitmap = new(stream.AsStream());
-        return bitmap;
+        Stream managedStream = stream.AsStream();
+        if (managedStream.CanSeek)
+            managedStream.Position = 0;
+
+        using Bitmap bitmap = new(managedStream);
+        return new Bitmap(bitmap);
     }
 
     public static BitmapImage GetBitmapImageFromIRandomAccessStream(IRandomAccessStream stream)
diff --git a/Text-Grab/Utilities/OcrUtilities.cs b/Text-Grab/Utilities/OcrUtilities.cs
index adffada9..74bb8859 100644
--- a/Text-Grab/Utilities/OcrUtilities.cs
+++ b/Text-Grab/Utilities/OcrUtilities.cs
@@ -131,6 +131,48 @@ public static async Task<string> GetRegionsTextAsTableAsync(Window passedWindow,
         return sb.ToString();
     }
 
+    public static async Task<string> GetTextFromBitmapAsync(Bitmap bitmap, ILanguage language)
+    {
+        return GetStringFromOcrOutputs(await GetTextFromImageAsync(bitmap, language));
+    }
+
+    public static async Task<string> GetTextFromBitmapSourceAsync(BitmapSource bitmapSource, ILanguage language)
+    {
+        using Bitmap bitmap = ImageMethods.BitmapSourceToBitmap(bitmapSource);
+        return await GetTextFromBitmapAsync(bitmap, language);
+    }
+
+    public static async Task<string> GetTextFromBitmapAsTableAsync(Bitmap bitmap, ILanguage language)
+    {
+        double scale = await GetIdealScaleFactorForOcrAsync(bitmap, language);
+        using Bitmap scaledBitmap = ImageMethods.ScaleBitmapUniform(bitmap, scale);
+        IOcrLinesWords ocrResult = await GetOcrResultFromImageAsync(scaledBitmap, language);
+        DpiScale bitmapDpiScale = new(1.0, 1.0);
+
+        List<WordBorderInfo> wordBorderInfos = ResultTable.ParseOcrResultIntoWordBorderInfos(ocrResult, bitmapDpiScale);
+
+        Rectangle rectCanvasSize = new()
+        {
+            Width = scaledBitmap.Width,
+            Height = scaledBitmap.Height,
+            X = 0,
+            Y = 0
+        };
+
+        ResultTable table = new();
+        table.AnalyzeAsTable(wordBorderInfos, rectCanvasSize);
+
+        StringBuilder textBuilder = new();
+        ResultTable.GetTextFromTabledWordBorders(textBuilder, wordBorderInfos, language.IsSpaceJoining());
+        return textBuilder.ToString();
+    }
+
+    public static async Task<string> GetTextFromBitmapSourceAsTableAsync(BitmapSource bitmapSource, ILanguage language)
+    {
+        using Bitmap bitmap = ImageMethods.BitmapSourceToBitmap(bitmapSource);
+        return await GetTextFromBitmapAsTableAsync(bitmap, language);
+    }
+
     public static async Task<(IOcrLinesWords?, double)> GetOcrResultFromRegionAsync(Rectangle region, ILanguage language)
     {
         Bitmap bmp = ImageMethods.GetRegionOfScreenAsBitmap(region);
@@ -191,6 +233,9 @@ public static async void GetCopyTextFromPreviousRegion()
         if (lastFsg is null)
             return;
 
+        if (!CanReplayPreviousFullscreenSelection(lastFsg))
+            return;
+
         Rect scaledRect = lastFsg.PositionRect.GetScaledUpByFraction(lastFsg.DpiScaleFactor);
 
         PreviousGrabWindow previousGrab = new(lastFsg.PositionRect);
@@ -224,6 +269,9 @@ public static async Task GetTextFromPreviousFullscreenRegion(TextBox? destinatio
         if (lastFsg is null)
             return;
 
+        if (!CanReplayPreviousFullscreenSelection(lastFsg))
+            return;
+
         Rect scaledRect = lastFsg.PositionRect.GetScaledUpByFraction(lastFsg.DpiScaleFactor);
 
         PreviousGrabWindow previousGrab = new(lastFsg.PositionRect);
@@ -254,13 +302,6 @@ public static async Task<List<OcrOutput>> GetTextFromRandomAccessStream(IRandomA
     {
         Bitmap bitmap = ImageMethods.GetBitmapFromIRandomAccessStream(randomAccessStream);
         List<OcrOutput> outputs = await GetTextFromImageAsync(bitmap, language);
-
-        if (DefaultSettings.TryToReadBarcodes)
-        {
-            OcrOutput barcodeResult = BarcodeUtilities.TryToReadBarcodes(bitmap);
-            outputs.Add(barcodeResult);
-        }
-
         return outputs;
     }
 
@@ -303,9 +344,9 @@ public static async Task<List<OcrOutput>> GetTextFromImageAsync(Bitmap bitmap, I
         {
             GlobalLang ocrLanguageFromILang = language as GlobalLang ?? new GlobalLang("en-US");
             double scale = await GetIdealScaleFactorForOcrAsync(bitmap, ocrLanguageFromILang);
-            Bitmap scaledBitmap = ImageMethods.ScaleBitmapUniform(bitmap, scale);
+            using Bitmap scaledBitmap = ImageMethods.ScaleBitmapUniform(bitmap, scale);
             IOcrLinesWords ocrResult = await OcrUtilities.GetOcrResultFromImageAsync(scaledBitmap, ocrLanguageFromILang);
-            OcrOutput paragraphsOutput = GetTextFromOcrResult(ocrLanguageFromILang, scaledBitmap, ocrResult);
+            OcrOutput paragraphsOutput = GetTextFromOcrResult(ocrLanguageFromILang, new Bitmap(scaledBitmap), ocrResult);
             outputs.Add(paragraphsOutput);
         }
 
@@ -483,4 +524,17 @@ public static async Task<string> OcrFile(string path, ILanguage? selectedLanguag
 
     [GeneratedRegex(@"(^[\p{L}-[\p{Lo}]]|\p{Nd}$)|.{2,}")]
     private static partial Regex SpaceJoiningWordRegex();
+
+    private static bool CanReplayPreviousFullscreenSelection(HistoryInfo history)
+    {
+        if (history.SelectionStyle is FsgSelectionStyle.Region or FsgSelectionStyle.AdjustAfter)
+            return true;
+
+        MessageBox.Show(
+            "Repeat previous fullscreen capture is currently available only for Region and Adjust After selections.",
+            "Text Grab",
+            MessageBoxButton.OK,
+            MessageBoxImage.Information);
+        return false;
+    }
 }
diff --git a/Text-Grab/Utilities/PostGrabActionManager.cs b/Text-Grab/Utilities/PostGrabActionManager.cs
index c5242595..00693031 100644
--- a/Text-Grab/Utilities/PostGrabActionManager.cs
+++ b/Text-Grab/Utilities/PostGrabActionManager.cs
@@ -4,6 +4,8 @@
 using System.Net;
 using System.Text.Json;
 using System.Threading.Tasks;
+using System.Windows;
+using Text_Grab.Interfaces;
 using Text_Grab.Models;
 using Text_Grab.Properties;
 using Wpf.Ui.Controls;
@@ -15,7 +17,8 @@ public class PostGrabActionManager
     private static readonly Settings DefaultSettings = AppUtilities.TextGrabSettings;
 
     /// <summary>
-    /// Gets all available post-grab actions from ButtonInfo.AllButtons filtered for FullscreenGrab relevance
+    /// Gets all available post-grab actions from ButtonInfo.AllButtons filtered for FullscreenGrab relevance.
+    /// Also includes a ButtonInfo for each saved Grab Template.
     /// </summary>
     public static List<ButtonInfo> GetAvailablePostGrabActions()
     {
@@ -24,9 +27,19 @@ public static List<ButtonInfo> GetAvailablePostGrabActions()
         // Add other relevant actions from AllButtons that are marked as relevant for FullscreenGrab
         IEnumerable<ButtonInfo> relevantActions = ButtonInfo.AllButtons
             .Where(button => button.IsRelevantForFullscreenGrab && !allPostGrabActions.Any(b => b.ButtonText == button.ButtonText));
-        
+
         allPostGrabActions.AddRange(relevantActions);
 
+        // Add a ButtonInfo for each saved Grab Template
+        List<GrabTemplate> templates = GrabTemplateManager.GetAllTemplates();
+        foreach (GrabTemplate template in templates)
+        {
+            ButtonInfo templateAction = GrabTemplateManager.CreateButtonInfoForTemplate(template);
+            // Avoid duplicates if it's somehow already in the list
+            if (!allPostGrabActions.Any(b => b.TemplateId == template.Id))
+                allPostGrabActions.Add(templateAction);
+        }
+
         return [.. allPostGrabActions.OrderBy(b => b.OrderNumber)];
     }
 
@@ -142,7 +155,7 @@ public static bool GetCheckState(ButtonInfo action)
             try
             {
                 Dictionary<string, bool>? checkStates = JsonSerializer.Deserialize<Dictionary<string, bool>>(statesJson);
-                if (checkStates is not null 
+                if (checkStates is not null
                     && checkStates.TryGetValue(action.ButtonText, out bool storedState)
                     && action.DefaultCheckState == DefaultCheckState.LastUsed)
                 {
@@ -191,6 +204,16 @@ public static void SaveCheckState(ButtonInfo action, bool isChecked)
     /// </summary>
     public static async Task<string> ExecutePostGrabAction(ButtonInfo action, string text)
     {
+        return await ExecutePostGrabAction(action, PostGrabContext.TextOnly(text));
+    }
+
+    /// <summary>
+    /// Executes a post-grab action using the full <see cref="PostGrabContext"/>.
+    /// Template actions use the context's CaptureRegion and DpiScale to re-OCR sub-regions.
+    /// </summary>
+    public static async Task<string> ExecutePostGrabAction(ButtonInfo action, PostGrabContext context)
+    {
+        string text = context.Text;
         string result = text;
 
         switch (action.ClickEvent)
@@ -236,6 +259,21 @@ public static async Task<string> ExecutePostGrabAction(ButtonInfo action, string
                 }
                 break;
 
+            case "ApplyTemplate_Click":
+                if (!string.IsNullOrWhiteSpace(action.TemplateId)
+                    && context.CaptureRegion != Rect.Empty)
+                {
+                    GrabTemplate? template = GrabTemplateManager.GetTemplateById(action.TemplateId);
+                    if (template is not null)
+                    {
+                        result = await GrabTemplateExecutor.ExecuteTemplateAsync(
+                            template, context.CaptureRegion, context.Language);
+                        GrabTemplateManager.RecordUsage(action.TemplateId);
+                    }
+                }
+                // If no capture region (e.g. called from EditTextWindow), skip template
+                break;
+
             default:
                 // Unknown action - return text unchanged
                 break;
diff --git a/Text-Grab/Utilities/WindowSelectionUtilities.cs b/Text-Grab/Utilities/WindowSelectionUtilities.cs
new file mode 100644
index 00000000..45706e4e
--- /dev/null
+++ b/Text-Grab/Utilities/WindowSelectionUtilities.cs
@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Windows;
+using Text_Grab.Models;
+
+namespace Text_Grab.Utilities;
+
+public static class WindowSelectionUtilities
+{
+    private const int DwmwaExtendedFrameBounds = 9;
+    private const int DwmwaCloaked = 14;
+    private const int GwlExStyle = -20;
+    private const int WsExToolWindow = 0x00000080;
+    private const int WsExNoActivate = 0x08000000;
+
+    public static List<WindowSelectionCandidate> GetCapturableWindows(IReadOnlyCollection<IntPtr>? excludedHandles = null)
+    {
+        HashSet<IntPtr> excluded = excludedHandles is null ? [] : [.. excludedHandles];
+        IntPtr shellWindow = OSInterop.GetShellWindow();
+        List<WindowSelectionCandidate> candidates = [];
+
+        _ = OSInterop.EnumWindows((windowHandle, _) =>
+        {
+            WindowSelectionCandidate? candidate = CreateCandidate(windowHandle, shellWindow, excluded);
+            if (candidate is not null)
+                candidates.Add(candidate);
+
+            return true;
+        }, IntPtr.Zero);
+
+        return candidates;
+    }
+
+    public static WindowSelectionCandidate? FindWindowAtPoint(IEnumerable<WindowSelectionCandidate> candidates, Point screenPoint)
+    {
+        return candidates.FirstOrDefault(candidate => candidate.Contains(screenPoint));
+    }
+
+    internal static bool IsValidWindowBounds(Rect bounds)
+    {
+        return bounds != Rect.Empty && bounds.Width > 20 && bounds.Height > 20;
+    }
+
+    private static WindowSelectionCandidate? CreateCandidate(IntPtr windowHandle, IntPtr shellWindow, ISet<IntPtr> excludedHandles)
+    {
+        if (windowHandle == IntPtr.Zero || windowHandle == shellWindow || excludedHandles.Contains(windowHandle))
+            return null;
+
+        if (!OSInterop.IsWindowVisible(windowHandle) || OSInterop.IsIconic(windowHandle))
+            return null;
+
+        if (IsCloaked(windowHandle))
+            return null;
+
+        int extendedStyle = OSInterop.GetWindowLong(windowHandle, GwlExStyle);
+        if ((extendedStyle & WsExToolWindow) != 0 || (extendedStyle & WsExNoActivate) != 0)
+            return null;
+
+        Rect bounds = GetWindowBounds(windowHandle);
+        if (!IsValidWindowBounds(bounds))
+            return null;
+
+        _ = OSInterop.GetWindowThreadProcessId(windowHandle, out uint processId);
+
+        return new WindowSelectionCandidate(
+            windowHandle,
+            bounds,
+            GetWindowTitle(windowHandle),
+            (int)processId,
+            GetProcessName((int)processId));
+    }
+
+    private static Rect GetWindowBounds(IntPtr windowHandle)
+    {
+        int rectSize = Marshal.SizeOf<OSInterop.RECT>();
+
+        if (OSInterop.DwmGetWindowAttribute(windowHandle, DwmwaExtendedFrameBounds, out OSInterop.RECT frameBounds, rectSize) == 0)
+        {
+            Rect extendedBounds = new(frameBounds.left, frameBounds.top, frameBounds.width, frameBounds.height);
+            if (IsValidWindowBounds(extendedBounds))
+                return extendedBounds;
+        }
+
+        if (OSInterop.GetWindowRect(windowHandle, out OSInterop.RECT windowRect))
+            return new Rect(windowRect.left, windowRect.top, windowRect.width, windowRect.height);
+
+        return Rect.Empty;
+    }
+
+    private static string GetWindowTitle(IntPtr windowHandle)
+    {
+        int titleLength = OSInterop.GetWindowTextLength(windowHandle);
+        if (titleLength <= 0)
+            return string.Empty;
+
+        StringBuilder titleBuilder = new(titleLength + 1);
+        _ = OSInterop.GetWindowText(windowHandle, titleBuilder, titleBuilder.Capacity);
+        return titleBuilder.ToString();
+    }
+
+    private static bool IsCloaked(IntPtr windowHandle)
+    {
+        return OSInterop.DwmGetWindowAttribute(windowHandle, DwmwaCloaked, out int cloakedState, sizeof(int)) == 0
+            && cloakedState != 0;
+    }
+
+    private static string GetProcessName(int processId)
+    {
+        try
+        {
+            using Process process = Process.GetProcessById(processId);
+            return process.ProcessName;
+        }
+        catch (ArgumentException)
+        {
+            return string.Empty;
+        }
+        catch (InvalidOperationException)
+        {
+            return string.Empty;
+        }
+        catch (Win32Exception)
+        {
+            return string.Empty;
+        }
+    }
+}
diff --git a/Text-Grab/Utilities/WindowUtilities.cs b/Text-Grab/Utilities/WindowUtilities.cs
index 8f7e9a3a..3c61f623 100644
--- a/Text-Grab/Utilities/WindowUtilities.cs
+++ b/Text-Grab/Utilities/WindowUtilities.cs
@@ -16,6 +16,8 @@ namespace Text_Grab.Utilities;
 
 public static partial class WindowUtilities
 {
+    private static Dictionary<string, bool>? fullscreenPostGrabActionStates;
+
     public static void AddTextToOpenWindow(string textToAdd)
     {
         WindowCollection allWindows = Application.Current.Windows;
@@ -77,6 +79,11 @@ public static void SetWindowPosition(Window passedWindow)
     }
 
     public static void LaunchFullScreenGrab(TextBox? destinationTextBox = null)
+    {
+        LaunchFullScreenGrab(destinationTextBox, null);
+    }
+
+    public static void LaunchFullScreenGrab(TextBox? destinationTextBox, string? preselectedTemplateId)
     {
         DisplayInfo[] allScreens = DisplayInfo.AllDisplayInfos;
         WindowCollection allWindows = Application.Current.Windows;
@@ -89,6 +96,9 @@ public static void LaunchFullScreenGrab(TextBox? destinationTextBox = null)
             if (window is FullscreenGrab grab)
                 allFullscreenGrab.Add(grab);
 
+        if (allFullscreenGrab.Count == 0)
+            ClearFullscreenPostGrabActionStates();
+
         int numberOfFullscreenGrabWindowsToCreate = numberOfScreens - allFullscreenGrab.Count;
 
         for (int i = 0; i < numberOfFullscreenGrabWindowsToCreate; i++)
@@ -107,6 +117,7 @@ public static void LaunchFullScreenGrab(TextBox? destinationTextBox = null)
             fullScreenGrab.Width = sideLength;
             fullScreenGrab.Height = sideLength;
             fullScreenGrab.DestinationTextBox = destinationTextBox;
+            fullScreenGrab.PreselectedTemplateId = preselectedTemplateId;
             fullScreenGrab.WindowState = WindowState.Normal;
 
             Point screenCenterPoint = screen.ScaledCenterPoint();
@@ -151,6 +162,7 @@ public static void CenterOverThisWindow(this Window newWindow, Window bottomWind
     internal static async void CloseAllFullscreenGrabs()
     {
         WindowCollection allWindows = Application.Current.Windows;
+        ClearFullscreenPostGrabActionStates();
 
         bool isFromEditWindow = false;
         string stringFromOCR = "";
@@ -197,6 +209,31 @@ internal static void FullscreenKeyDown(Key key, bool? isActive = null)
                 fsg.KeyPressed(key, isActive);
     }
 
+    internal static void SyncFullscreenPostGrabActionStates(IReadOnlyDictionary<string, bool> actionStates, FullscreenGrab? sourceWindow = null)
+    {
+        fullscreenPostGrabActionStates = new Dictionary<string, bool>(actionStates);
+
+        WindowCollection allWindows = Application.Current.Windows;
+        foreach (Window window in allWindows)
+        {
+            if (window is FullscreenGrab fsg && fsg != sourceWindow)
+                fsg.ApplyPostGrabActionSnapshot(fullscreenPostGrabActionStates);
+        }
+    }
+
+    internal static IReadOnlyDictionary<string, bool>? GetFullscreenPostGrabActionStates()
+    {
+        if (fullscreenPostGrabActionStates is null || fullscreenPostGrabActionStates.Count == 0)
+            return null;
+
+        return new Dictionary<string, bool>(fullscreenPostGrabActionStates);
+    }
+
+    internal static void ClearFullscreenPostGrabActionStates()
+    {
+        fullscreenPostGrabActionStates = null;
+    }
+
     internal static async Task TryInsertString(string stringToInsert)
     {
         await Task.Delay(TimeSpan.FromSeconds(AppUtilities.TextGrabSettings.InsertDelay));
diff --git a/Text-Grab/Views/EditTextWindow.xaml b/Text-Grab/Views/EditTextWindow.xaml
index e42947e9..3b25d90d 100644
--- a/Text-Grab/Views/EditTextWindow.xaml
+++ b/Text-Grab/Views/EditTextWindow.xaml
@@ -24,130 +24,124 @@
     WindowStartupLocation="CenterScreen"
     mc:Ignorable="d">
     <Window.Resources>
-        <Style x:Key="SimpleBTN"
-                TargetType="Button">
-            <Setter Property="Width"
-                    Value="120"/>
-            <Setter Property="Padding"
-                    Value="6"/>
-            <Setter Property="Margin"
-                    Value="10,10,0,10"/>
+        <Style x:Key="SimpleBTN" TargetType="Button">
+            <Setter Property="Width" Value="120" />
+            <Setter Property="Padding" Value="6" />
+            <Setter Property="Margin" Value="10,10,0,10" />
         </Style>
-        <ui:ImageIcon x:Key="TextGrabIcon"
-                Source="/Text-Grab;component/Images/TealSelect40.png"/>
+        <ui:ImageIcon x:Key="TextGrabIcon" Source="/Text-Grab;component/Images/TealSelect40.png" />
         <ContextMenu x:Key="ContextMenuResource">
-            <MenuItem Command="ApplicationCommands.Undo"/>
-            <MenuItem Command="ApplicationCommands.Redo"/>
-            <Separator/>
-            <MenuItem Command="ApplicationCommands.Cut"/>
-            <MenuItem Command="ApplicationCommands.Copy"/>
-            <MenuItem Command="ApplicationCommands.Paste"/>
+            <MenuItem Command="ApplicationCommands.Undo" />
+            <MenuItem Command="ApplicationCommands.Redo" />
+            <Separator />
+            <MenuItem Command="ApplicationCommands.Cut" />
+            <MenuItem Command="ApplicationCommands.Copy" />
+            <MenuItem Command="ApplicationCommands.Paste" />
             <MenuItem
                 Command="{x:Static local:EditTextWindow.OcrPasteCommand}"
                 Header="OCR Paste"
-                InputGestureText="Ctrl + Shift + V"/>
-            <Separator/>
+                InputGestureText="Ctrl + Shift + V" />
+            <Separator />
             <MenuItem
                 Command="{x:Static local:EditTextWindow.IsolateSelectionCmd}"
                 Header="Isolate Selected Text"
-                InputGestureText="Ctrl + I"/>
+                InputGestureText="Ctrl + I" />
             <MenuItem
                 Click="SelectLineMenuItem_Click"
                 Header="Select Line"
-                InputGestureText="Ctrl + L"/>
+                InputGestureText="Ctrl + L" />
             <MenuItem
                 Click="SelectAllMenuItem_Click"
                 Header="Select All"
-                InputGestureText="Ctrl + A"/>
+                InputGestureText="Ctrl + A" />
             <MenuItem
                 Command="{x:Static local:EditTextWindow.ToggleCaseCmd}"
                 Header="Toggle Case"
-                InputGestureText="Shift + F3"/>
-            <MenuItem Click="DeleteSelectedTextMenuItem_Click"
-                    Header="Delete Selected Text"/>
-            <Separator/>
+                InputGestureText="Shift + F3" />
+            <MenuItem Click="DeleteSelectedTextMenuItem_Click" Header="Delete Selected Text" />
+            <Separator />
             <MenuItem
                 Click="MoveLineUpMenuItem_Click"
                 Header="Move Selection Up"
-                InputGestureText="Alt + Up"/>
+                InputGestureText="Alt + Up" />
             <MenuItem
                 Click="MoveLineDownMenuItem_Click"
                 Header="Move Selection Down"
-                InputGestureText="Alt + Down"/>
+                InputGestureText="Alt + Down" />
         </ContextMenu>
     </Window.Resources>
     <Window.CommandBindings>
         <CommandBinding
             CanExecute="SplitOnSelectionCmdCanExecute"
             Command="{x:Static local:EditTextWindow.SplitOnSelectionCmd}"
-            Executed="SplitOnSelectionCmdExecuted"/>
+            Executed="SplitOnSelectionCmdExecuted" />
         <CommandBinding
             CanExecute="SplitOnSelectionCmdCanExecute"
             Command="{x:Static local:EditTextWindow.SplitAfterSelectionCmd}"
-            Executed="SplitAfterSelectionCmdExecuted"/>
+            Executed="SplitAfterSelectionCmdExecuted" />
         <CommandBinding
             CanExecute="IsolateSelectionCmdCanExecute"
             Command="{x:Static local:EditTextWindow.IsolateSelectionCmd}"
-            Executed="IsolateSelectionCmdExecuted"/>
+            Executed="IsolateSelectionCmdExecuted" />
         <CommandBinding
             CanExecute="SingleLineCmdCanExecute"
             Command="{x:Static local:EditTextWindow.SingleLineCmd}"
-            Executed="SingleLineCmdExecuted"/>
+            Executed="SingleLineCmdExecuted" />
         <CommandBinding
             CanExecute="ToggleCaseCmdCanExecute"
             Command="{x:Static local:EditTextWindow.ToggleCaseCmd}"
-            Executed="ToggleCase"/>
+            Executed="ToggleCase" />
         <CommandBinding
             CanExecute="ReplaceReservedCharsCmdCanExecute"
             Command="{x:Static local:EditTextWindow.ReplaceReservedCmd}"
-            Executed="ReplaceReservedCharsCmdExecuted"/>
+            Executed="ReplaceReservedCharsCmdExecuted" />
         <CommandBinding
             CanExecute="SelectionContainsNewLinesCmdCanExecute"
             Command="{x:Static local:EditTextWindow.UnstackCmd}"
-            Executed="UnstackExecuted"/>
+            Executed="UnstackExecuted" />
         <CommandBinding
             CanExecute="SelectionContainsNewLinesCmdCanExecute"
             Command="{x:Static local:EditTextWindow.UnstackGroupCmd}"
-            Executed="UnstackGroupExecuted"/>
+            Executed="UnstackGroupExecuted" />
         <CommandBinding
             CanExecute="IsolateSelectionCmdCanExecute"
             Command="{x:Static local:EditTextWindow.DeleteAllSelectionCmd}"
-            Executed="DeleteAllSelectionExecuted"/>
+            Executed="DeleteAllSelectionExecuted" />
         <CommandBinding
             CanExecute="IsolateSelectionCmdCanExecute"
             Command="{x:Static local:EditTextWindow.DeleteAllSelectionPatternCmd}"
-            Executed="DeleteAllSelectionPatternExecuted"/>
+            Executed="DeleteAllSelectionPatternExecuted" />
         <CommandBinding
             CanExecute="InsertSelectionOnEveryLineCmdCanExecute"
             Command="{x:Static local:EditTextWindow.InsertSelectionOnEveryLineCmd}"
-            Executed="InsertSelectionOnEveryLine"/>
+            Executed="InsertSelectionOnEveryLine" />
         <CommandBinding
             CanExecute="CanOcrPasteExecute"
             Command="{x:Static local:EditTextWindow.OcrPasteCommand}"
-            Executed="PasteExecuted"/>
+            Executed="PasteExecuted" />
         <CommandBinding
             CanExecute="CanLaunchUriExecute"
             Command="{x:Static local:EditTextWindow.LaunchCmd}"
-            Executed="LaunchUriExecuted"/>
+            Executed="LaunchUriExecuted" />
         <CommandBinding
             CanExecute="MakeQrCodeCanExecute"
             Command="{x:Static local:EditTextWindow.MakeQrCodeCmd}"
-            Executed="MakeQrCodeExecuted"/>
+            Executed="MakeQrCodeExecuted" />
         <CommandBinding
             CanExecute="IsolateSelectionCmdCanExecute"
             Command="{x:Static local:EditTextWindow.WebSearchCmd}"
-            Executed="WebSearchExecuted"/>
+            Executed="WebSearchExecuted" />
         <CommandBinding
             CanExecute="IsolateSelectionCmdCanExecute"
             Command="{x:Static local:EditTextWindow.DefaultWebSearchCmd}"
-            Executed="DefaultWebSearchExecuted"/>
+            Executed="DefaultWebSearchExecuted" />
     </Window.CommandBindings>
     <Grid Background="{DynamicResource SolidBackgroundFillColorBaseBrush}">
         <Grid.RowDefinitions>
-            <RowDefinition Height="auto"/>
-            <RowDefinition Height="auto"/>
-            <RowDefinition Height="*"/>
-            <RowDefinition Height="auto"/>
+            <RowDefinition Height="auto" />
+            <RowDefinition Height="auto" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="auto" />
         </Grid.RowDefinitions>
         <ui:TitleBar
             x:Name="UiTitleBar"
@@ -155,192 +149,188 @@
             Height="32"
             Margin="2,2,2,0"
             Padding="8,2"
-            Icon="{StaticResource TextGrabIcon}"/>
+            Icon="{StaticResource TextGrabIcon}" />
         <Grid Grid.Row="1">
             <Grid.ColumnDefinitions>
-                <ColumnDefinition Width="Auto"/>
-                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="Auto" />
+                <ColumnDefinition Width="*" />
             </Grid.ColumnDefinitions>
             <Menu
                 Grid.Column="0"
                 ClipToBounds="True"
                 IsMainMenu="True">
-                <MenuItem Header="_File"
-                        SubmenuOpened="MenuItem_SubmenuOpened">
+                <MenuItem Header="_File" SubmenuOpened="MenuItem_SubmenuOpened">
                     <MenuItem
                         x:Name="OpenFileMenuItem"
                         Click="OpenFileMenuItem_Click"
                         Header="_Open File..."
-                        InputGestureText="Ctrl + O"/>
-                    <MenuItem x:Name="OpenRecentMenuItem"
-                            Header="Recent"/>
-                    <MenuItem x:Name="OpenRecentGrabsMenuItem"
-                            Header="Recent Grabs"/>
+                        InputGestureText="Ctrl + O" />
+                    <MenuItem x:Name="OpenRecentMenuItem" Header="Recent" />
+                    <MenuItem x:Name="OpenRecentGrabsMenuItem" Header="Recent Grabs" />
                     <MenuItem
                         x:Name="SaveFileMenuItem"
                         Click="SaveBTN_Click"
                         Header="_Save"
-                        InputGestureText="Ctrl + S"/>
+                        InputGestureText="Ctrl + S" />
                     <MenuItem
                         x:Name="SaveAsFileMenuItem"
                         Click="SaveAsBTN_Click"
                         Header="Save _As..."
-                        InputGestureText="Ctrl + Shift + S"/>
+                        InputGestureText="Ctrl + Shift + S" />
                     <MenuItem
                         x:Name="CopyAndCloseMenuItem"
                         Click="CopyCloseBTN_Click"
-                        Header="_Copy And Close"/>
+                        Header="_Copy And Close" />
                     <MenuItem
                         x:Name="CloseAndInsertMenuItem"
                         Click="CopyClosePasteBTN_Click"
-                        Header="Close and I_nsert"/>
-                    <Separator/>
+                        Header="Close and I_nsert" />
+                    <Separator />
                     <MenuItem
                         x:Name="SettingsMenuItem"
                         Click="SettingsMenuItem_Click"
-                        Header="Text Grab Sett_ings..."/>
+                        Header="Text Grab Sett_ings..." />
                     <MenuItem
                         x:Name="CloseMenuItem"
                         Click="CloseMenuItem_Click"
                         Header="Close"
-                        InputGestureText="Alt + F4"/>
+                        InputGestureText="Alt + F4" />
                 </MenuItem>
                 <MenuItem Header="_Edit">
-                    <MenuItem Command="ApplicationCommands.Undo"/>
-                    <MenuItem Command="ApplicationCommands.Redo"/>
-                    <Separator/>
-                    <MenuItem Command="ApplicationCommands.Cut"/>
-                    <MenuItem Command="ApplicationCommands.Copy"/>
-                    <MenuItem Command="ApplicationCommands.Paste"/>
+                    <MenuItem Command="ApplicationCommands.Undo" />
+                    <MenuItem Command="ApplicationCommands.Redo" />
+                    <Separator />
+                    <MenuItem Command="ApplicationCommands.Cut" />
+                    <MenuItem Command="ApplicationCommands.Copy" />
+                    <MenuItem Command="ApplicationCommands.Paste" />
                     <MenuItem
                         Command="{x:Static local:EditTextWindow.OcrPasteCommand}"
                         Header="OCR Paste"
-                        InputGestureText="Ctrl + Shift + V"/>
-                    <Separator/>
+                        InputGestureText="Ctrl + Shift + V" />
+                    <Separator />
                     <MenuItem
                         x:Name="LaunchUriMenuItem"
                         Command="{x:Static local:EditTextWindow.LaunchCmd}"
-                        Header="Launch URL"/>
+                        Header="Launch URL" />
                     <MenuItem
                         x:Name="SingleLineMenuItem"
                         Command="{x:Static local:EditTextWindow.SingleLineCmd}"
-                        Header="Make _Single Line"/>
+                        Header="Make _Single Line" />
                     <MenuItem
                         x:Name="_TrimEachLineMenuItem"
                         Click="TrimEachLineMenuItem_Click"
-                        Header="_Trim Each Line"/>
+                        Header="_Trim Each Line" />
                     <MenuItem
                         x:Name="TryToNumberMenuItem"
                         Click="TryToNumberMenuItem_Click"
-                        Header="Try To Make _Numbers"/>
+                        Header="Try To Make _Numbers" />
                     <MenuItem
                         x:Name="TryToAlphaMenuItem"
                         Click="TryToAlphaMenuItem_Click"
-                        Header="Try To Make _Letters"/>
+                        Header="Try To Make _Letters" />
                     <MenuItem
                         x:Name="CorrectGuid"
                         Click="CorrectGuid_Click"
-                        Header="Correct Common _GUID/UUID Errors"/>
+                        Header="Correct Common _GUID/UUID Errors" />
                     <MenuItem
                         x:Name="ToggleCaseMenuItem"
                         Command="{x:Static local:EditTextWindow.ToggleCaseCmd}"
                         Header="Toggle _Case"
-                        InputGestureText="Shift + F3"/>
+                        InputGestureText="Shift + F3" />
                     <MenuItem
                         x:Name="RemoveDuplicateLines"
                         Click="RemoveDuplicateLines_Click"
-                        Header="Remove Duplicate Lines"/>
+                        Header="Remove Duplicate Lines" />
                     <MenuItem
                         x:Name="ReplaceReservedCharsMenuItem"
                         Command="{x:Static local:EditTextWindow.ReplaceReservedCmd}"
                         Header="_Replace Reserved Characters"
-                        InputGestureText="Ctrl + R"/>
+                        InputGestureText="Ctrl + R" />
                     <MenuItem
                         x:Name="UnStackMenuItem"
                         Command="{x:Static local:EditTextWindow.UnstackCmd}"
                         Header="_Unstack Text (Select Top Row)"
-                        InputGestureText="Ctrl + U"/>
+                        InputGestureText="Ctrl + U" />
                     <MenuItem
                         x:Name="UnStackGroupMenuItem"
                         Command="{x:Static local:EditTextWindow.UnstackGroupCmd}"
-                        Header="_Unstack Text (Select First Column)"/>
+                        Header="_Unstack Text (Select First Column)" />
                     <MenuItem
                         x:Name="AddRemoveAtMenuItem"
                         Click="AddRemoveAtMenuItem_Click"
-                        Header="_Add, Remove, Limit..."/>
+                        Header="_Add, Remove, Limit..." />
                 </MenuItem>
                 <MenuItem Header="_Selection">
                     <MenuItem
                         x:Name="FindAndReplaceMenuItem"
                         Click="FindAndReplaceMenuItem_Click"
-                        Header="Find and Replace"/>
+                        Header="Find and Replace" />
                     <MenuItem
                         x:Name="DefaultWebSearch"
                         Command="{x:Static local:EditTextWindow.DefaultWebSearchCmd}"
-                        Header="Default Web Search"/>
-                    <MenuItem x:Name="WebSearchCollection"
-                            Header="Search web with..."/>
-                    <Separator/>
+                        Header="Default Web Search" />
+                    <MenuItem x:Name="WebSearchCollection" Header="Search web with..." />
+                    <Separator />
                     <MenuItem
                         x:Name="SelectWordMenuItem"
                         Click="SelectWordMenuItem_Click"
                         Header="Select _Word"
-                        InputGestureText="Ctrl + W"/>
+                        InputGestureText="Ctrl + W" />
                     <MenuItem
                         x:Name="SelectLineMenuItem"
                         Click="SelectLineMenuItem_Click"
                         Header="Select _Line"
-                        InputGestureText="Ctrl + L"/>
+                        InputGestureText="Ctrl + L" />
                     <MenuItem
                         x:Name="SelectAllMenuItem"
                         Click="SelectAllMenuItem_Click"
                         Header="Select All"
-                        InputGestureText="Ctrl + A"/>
+                        InputGestureText="Ctrl + A" />
                     <MenuItem
                         x:Name="SelectNoneMenuItem"
                         Click="SelectNoneMenuItem_Click"
-                        Header="Select None"/>
+                        Header="Select None" />
                     <MenuItem
                         x:Name="DeleteSelectedTextMenuItem"
                         Click="DeleteSelectedTextMenuItem_Click"
-                        Header="Delete Selected Text"/>
-                    <Separator/>
+                        Header="Delete Selected Text" />
+                    <Separator />
                     <MenuItem
                         x:Name="MoveLineUpMenuItem"
                         Click="MoveLineUpMenuItem_Click"
                         Header="Move Selection _Up"
-                        InputGestureText="Alt + Up"/>
+                        InputGestureText="Alt + Up" />
                     <MenuItem
                         x:Name="MoveLineDownMenuItem"
                         Click="MoveLineDownMenuItem_Click"
                         Header="Move Selection _Down"
-                        InputGestureText="Alt + Down"/>
-                    <Separator/>
+                        InputGestureText="Alt + Down" />
+                    <Separator />
                     <MenuItem
                         x:Name="SplitLineBeforeSelectionMI"
                         Command="{x:Static local:EditTextWindow.SplitOnSelectionCmd}"
-                        Header="Split Lines _Before Each Selection"/>
+                        Header="Split Lines _Before Each Selection" />
                     <MenuItem
                         x:Name="SplitLineAfterSelectionMI"
                         Command="{x:Static local:EditTextWindow.SplitAfterSelectionCmd}"
-                        Header="Split Lines _After Each Selection"/>
+                        Header="Split Lines _After Each Selection" />
                     <MenuItem
                         x:Name="IsolateSelectionMI"
                         Command="{x:Static local:EditTextWindow.IsolateSelectionCmd}"
                         Header="_Isolate Selected Text"
-                        InputGestureText="Ctrl + I"/>
+                        InputGestureText="Ctrl + I" />
                     <MenuItem
                         x:Name="DeleteAllSelectionMI"
                         Command="{x:Static local:EditTextWindow.DeleteAllSelectionCmd}"
-                        Header="Delete All Instances of Selection"/>
+                        Header="Delete All Instances of Selection" />
                     <MenuItem
                         x:Name="DeleteAllSelectionPatternMI"
                         Command="{x:Static local:EditTextWindow.DeleteAllSelectionPatternCmd}"
-                        Header="Delete All Instances of Selection Simple Pattern"/>
+                        Header="Delete All Instances of Selection Simple Pattern" />
                     <MenuItem
                         x:Name="InsertSelectionOnEveryLineMI"
                         Command="{x:Static local:EditTextWindow.InsertSelectionOnEveryLineCmd}"
-                        Header="Insert Selection On Every Line"/>
+                        Header="Insert Selection On Every Line" />
                 </MenuItem>
                 <MenuItem
                     Name="AiMenuItem"
@@ -349,102 +339,101 @@
                     <MenuItem
                         x:Name="SummarizeMenuItem"
                         Click="SummarizeMenuItem_Click"
-                        Header="_Summarize Paragraph"/>
+                        Header="_Summarize Paragraph" />
                     <MenuItem
                         x:Name="RewriteMenuItem"
                         Click="RewriteMenuItem_Click"
-                        Header="_Rewrite"/>
+                        Header="_Rewrite" />
                     <MenuItem
                         x:Name="ConvertTableMenuItem"
                         Click="ConvertTableMenuItem_Click"
-                        Header="_Convert to Table"/>
+                        Header="_Convert to Table" />
                     <MenuItem
                         x:Name="TranslateToSystemLanguageMenuItem"
                         Click="TranslateToSystemLanguageMenuItem_Click"
-                        Header="Translate to System Language"/>
-                    <MenuItem x:Name="TranslateMenuItem"
-                            Header="_Translate to...">
+                        Header="Translate to System Language" />
+                    <MenuItem x:Name="TranslateMenuItem" Header="_Translate to...">
                         <MenuItem
                             Click="TranslateMenuItem_Click"
                             Header="English"
-                            Tag="English"/>
+                            Tag="English" />
                         <MenuItem
                             Click="TranslateMenuItem_Click"
                             Header="Spanish"
-                            Tag="Spanish"/>
+                            Tag="Spanish" />
                         <MenuItem
                             Click="TranslateMenuItem_Click"
                             Header="French"
-                            Tag="French"/>
+                            Tag="French" />
                         <MenuItem
                             Click="TranslateMenuItem_Click"
                             Header="German"
-                            Tag="German"/>
+                            Tag="German" />
                         <MenuItem
                             Click="TranslateMenuItem_Click"
                             Header="Italian"
-                            Tag="Italian"/>
+                            Tag="Italian" />
                         <MenuItem
                             Click="TranslateMenuItem_Click"
                             Header="Portuguese"
-                            Tag="Portuguese"/>
+                            Tag="Portuguese" />
                         <MenuItem
                             Click="TranslateMenuItem_Click"
                             Header="Russian"
-                            Tag="Russian"/>
+                            Tag="Russian" />
                         <MenuItem
                             Click="TranslateMenuItem_Click"
                             Header="Japanese"
-                            Tag="Japanese"/>
+                            Tag="Japanese" />
                         <MenuItem
                             Click="TranslateMenuItem_Click"
                             Header="Chinese (Simplified)"
-                            Tag="Chinese (Simplified)"/>
+                            Tag="Chinese (Simplified)" />
                         <MenuItem
                             Click="TranslateMenuItem_Click"
                             Header="Korean"
-                            Tag="Korean"/>
+                            Tag="Korean" />
                         <MenuItem
                             Click="TranslateMenuItem_Click"
                             Header="Arabic"
-                            Tag="Arabic"/>
+                            Tag="Arabic" />
                         <MenuItem
                             Click="TranslateMenuItem_Click"
                             Header="Hindi"
-                            Tag="Hindi"/>
+                            Tag="Hindi" />
                     </MenuItem>
                     <MenuItem
                         x:Name="ExtractRegexMenuItem"
                         Click="ExtractRegexMenuItem_Click"
-                        Header="E_xtract RegEx"/>
+                        Header="E_xtract RegEx" />
                     <MenuItem
                         x:Name="LearnAiMenuItem"
                         Click="LearnAiMenuItem_Click"
-                        Header="_Learn About Local AI Features..."/>
+                        Header="_Learn About Local AI Features..." />
                 </MenuItem>
                 <MenuItem Header="F_ormat">
                     <MenuItem
                         x:Name="ShowErrorsMenuItem"
                         Click="ShowErrorsMenuItem_Click"
                         Header="Show Math Errors"
-                        IsCheckable="True"/>
+                        IsCheckable="True" />
                     <MenuItem
                         x:Name="MarginsMenuItem"
                         Checked="MarginsMenuItem_Checked"
                         Header="_Use Margins"
                         IsCheckable="True"
-                        Unchecked="MarginsMenuItem_Checked"/>
+                        Unchecked="MarginsMenuItem_Checked" />
                     <MenuItem
                         x:Name="WrapTextMenuItem"
                         Checked="WrapTextCHBX_Checked"
                         Header="_Wrap Text"
                         IsCheckable="True"
                         IsChecked="True"
-                        Unchecked="WrapTextCHBX_Checked"/>
+                        Unchecked="WrapTextCHBX_Checked" />
                     <MenuItem
                         x:Name="FontMenuItem"
                         Click="FontMenuItem_Click"
-                        Header="_Font..."/>
+                        Header="_Font..." />
                 </MenuItem>
                 <MenuItem
                     x:Name="CaptureMenuItem"
@@ -454,71 +443,74 @@
                         x:Name="FullScreenGrabMenuItem"
                         Click="FullScreenGrabMenuItem_Click"
                         Header="New _Fullscreen Grab"
-                        InputGestureText="Ctrl + F"/>
+                        InputGestureText="Ctrl + F" />
                     <MenuItem
                         x:Name="FSGDelayMenuItem"
                         Click="FSGDelayMenuItem_Click"
-                        Header="Fullscreen with 2 second _delay"/>
+                        Header="Fullscreen with 2 second _delay" />
                     <MenuItem
                         x:Name="PreviousRegionMenuItem"
                         Click="PreviousRegion_Click"
-                        Header="Grab previous region"/>
+                        Header="Grab previous region" />
                     <MenuItem
                         x:Name="GrabFrameMenuItem"
                         Click="GrabFrameMenuItem_Click"
                         Header="New _Grab Frame"
-                        InputGestureText="Ctrl + G"/>
-                    <Separator/>
+                        InputGestureText="Ctrl + G" />
+                    <MenuItem
+                        x:Name="ManageGrabTemplatesMenuItem"
+                        Click="ManageGrabTemplates_Click"
+                        Header="Manage Grab _Templates..." />
+                    <Separator />
                     <MenuItem
                         x:Name="QuickSimpleLookupMenuItem"
                         Click="LaunchQuickSimpleLookup"
                         Header="Add From _Quick Simple Lookup"
-                        InputGestureText="Ctrl + Q"/>
+                        InputGestureText="Ctrl + Q" />
                     <MenuItem
                         x:Name="ClipboardWatcherMenuItem"
                         Header="_Watch Clipboard For Changes"
                         IsCheckable="True"
-                        IsChecked="False"/>
-                    <Separator/>
+                        IsChecked="False" />
+                    <Separator />
                     <MenuItem
                         x:Name="ListFilesMenuItem"
                         Click="ListFilesMenuItem_Click"
-                        Header="_List Files and Folders From Folder..."/>
-                    <Separator/>
+                        Header="_List Files and Folders From Folder..." />
+                    <Separator />
                     <MenuItem
                         x:Name="ReadFolderOfImages"
                         Click="ReadFolderOfImages_Click"
-                        Header="_Extract Text from Images in Folder..."/>
-                    <MenuItem x:Name="LanguageMenuItem"
-                            Header="OCR in Language..."/>
+                        Header="_Extract Text from Images in Folder..." />
+                    <MenuItem x:Name="LanguageMenuItem" Header="OCR in Language..." />
                     <MenuItem
                         x:Name="RecursiveFoldersCheck"
                         Header="Scan all folders recursively"
                         IsCheckable="True"
-                        StaysOpenOnClick="True"/>
+                        StaysOpenOnClick="True" />
                     <MenuItem
                         x:Name="ReadFolderOfImagesWriteTxtFiles"
                         Header="Write ._Txt File For Each Image"
                         IsCheckable="True"
-                        StaysOpenOnClick="True"/>
+                        StaysOpenOnClick="True" />
                     <MenuItem
                         x:Name="OutputFilenamesCheck"
                         Header="Write File names in output"
                         IsCheckable="True"
                         IsChecked="True"
-                        StaysOpenOnClick="True"/>
+                        StaysOpenOnClick="True" />
                     <MenuItem
                         x:Name="OutputHeaderCheck"
                         Header="Include output header text"
                         IsCheckable="True"
                         IsChecked="True"
-                        StaysOpenOnClick="True"/>
+                        StaysOpenOnClick="True" />
                     <MenuItem
                         x:Name="OutputFooterCheck"
                         Header="Include output footer text"
                         IsCheckable="True"
                         IsChecked="True"
-                        StaysOpenOnClick="True"/>
+                        StaysOpenOnClick="True" />
                 </MenuItem>
                 <MenuItem
                     x:Name="WindowMenuItem"
@@ -529,69 +521,69 @@
                         Click="AlwaysOnTop_Checked"
                         Header="_Always On Top"
                         IsCheckable="True"
-                        IsChecked="False"/>
+                        IsChecked="False" />
                     <MenuItem
                         x:Name="HideBottomBarMenuItem"
                         Click="HideBottomBarMenuItem_Click"
                         Header="_Hide Bottom Bar"
                         IsCheckable="True"
-                        IsChecked="False"/>
+                        IsChecked="False" />
                     <MenuItem
                         x:Name="LaunchFullscreenOnLoad"
                         Click="LaunchFullscreenOnLoad_Click"
                         Header="Open _Fullscreen on Launch"
                         IsCheckable="True"
-                        IsChecked="False"/>
+                        IsChecked="False" />
                     <MenuItem
                         x:Name="RestorePositionMenuItem"
                         Checked="RestorePositionMenuItem_Checked"
                         Header="Set postion based on previous Edit Text Window"
                         IsCheckable="True"
-                        Unchecked="RestorePositionMenuItem_Checked"/>
+                        Unchecked="RestorePositionMenuItem_Checked" />
                     <MenuItem
                         x:Name="RestoreThisPosition"
                         Click="RestoreThisPosition_Click"
-                        Header="_Restore this windows's position"/>
+                        Header="_Restore this windows's position" />
                     <MenuItem
                         x:Name="ShowCalcPaneMenuItem"
                         Click="ShowCalcPaneMenuItem_Click"
                         Header="Show calculations pane"
-                        IsCheckable="True"/>
-                    <Separator/>
+                        IsCheckable="True" />
+                    <Separator />
                     <MenuItem
                         x:Name="NewWindowMenuItem"
                         Click="NewWindow_Clicked"
-                        Header="_New Window"/>
+                        Header="_New Window" />
                     <MenuItem
                         x:Name="NewWindowFromSelectionMenuItem"
                         Click="NewWindowWithText_Clicked"
-                        Header="New Window with Selected _Text"/>
+                        Header="New Window with Selected _Text" />
                     <MenuItem
                         x:Name="MakeCodeMenuItem"
                         Command="{x:Static local:EditTextWindow.MakeQrCodeCmd}"
-                        Header="Make _QR Code"/>
+                        Header="Make _QR Code" />
                     <MenuItem
                         x:Name="OpenLastAsGrabFrameMenuItem"
                         Click="OpenLastAsGrabFrameMenuItem_Click"
-                        Header="Edit _Last Grab"/>
+                        Header="Edit _Last Grab" />
                 </MenuItem>
                 <MenuItem Header="_Help">
                     <MenuItem
                         x:Name="ContactMenuItem"
                         Click="ContactMenuItem_Click"
-                        Header="_Contact The Developer..."/>
+                        Header="_Contact The Developer..." />
                     <MenuItem
                         x:Name="RateAndReview"
                         Click="RateAndReview_Click"
-                        Header="_Rate and Review..."/>
+                        Header="_Rate and Review..." />
                     <MenuItem
                         x:Name="FeedbackMenuItem"
                         Click="FeedbackMenuItem_Click"
-                        Header="_Feedback..."/>
+                        Header="_Feedback..." />
                     <MenuItem
                         x:Name="AboutMenuItem"
                         Click="AboutMenuItem_Click"
-                        Header="_About"/>
+                        Header="_About" />
                 </MenuItem>
             </Menu>
             <Button
@@ -607,15 +599,13 @@
                 BorderThickness="0"
                 Click="CalcToggleButton_Click"
                 ToolTip="Toggle Calculation Pane (Ctrl+P)&#x0a;Note: Text wrapping is disabled when calc pane is visible for better vertical alignment">
-                <ui:SymbolIcon FontSize="16"
-                        Symbol="Calculator24"/>
+                <ui:SymbolIcon FontSize="16" Symbol="Calculator24" />
             </Button>
         </Grid>
         <Grid Grid.Row="2">
             <Grid.ColumnDefinitions>
-                <ColumnDefinition Width="*"/>
-                <ColumnDefinition x:Name="CalcColumn"
-                        Width="200"/>
+                <ColumnDefinition Width="*" />
+                <ColumnDefinition x:Name="CalcColumn" Width="200" />
             </Grid.ColumnDefinitions>
             <TextBox
                 x:Name="PassedTextControl"
@@ -637,7 +627,7 @@
                 Style="{DynamicResource TextBoxStyle2}"
                 TextChanged="PassedTextControl_TextChanged"
                 TextWrapping="WrapWithOverflow"
-                VerticalScrollBarVisibility="Auto"/>
+                VerticalScrollBarVisibility="Auto" />
             <TextBox
                 x:Name="CalcResultsTextControl"
                 Grid.Column="1"
@@ -655,41 +645,38 @@
                 VerticalScrollBarVisibility="Hidden">
                 <TextBox.ContextMenu>
                     <ContextMenu>
-                        <MenuItem Name="HideCalcPaneContextItem"
-                                Header="Hide Pane"/>
-                        <MenuItem Name="ShowCalcErrorsContextItem"
-                                Header="Show Errors"/>
-                        <MenuItem Name="CopyAllContextItem"
-                                Header="Copy All"/>
-                        <Separator/>
+                        <MenuItem Name="HideCalcPaneContextItem" Header="Hide Pane" />
+                        <MenuItem Name="ShowCalcErrorsContextItem" Header="Show Errors" />
+                        <MenuItem Name="CopyAllContextItem" Header="Copy All" />
+                        <Separator />
                         <MenuItem
                             Name="ShowSumContextItem"
                             Header="Sum: -"
-                            IsCheckable="True"/>
+                            IsCheckable="True" />
                         <MenuItem
                             Name="ShowAverageContextItem"
                             Header="Average: -"
-                            IsCheckable="True"/>
+                            IsCheckable="True" />
                         <MenuItem
                             Name="ShowMedianContextItem"
                             Header="Median: -"
-                            IsCheckable="True"/>
+                            IsCheckable="True" />
                         <MenuItem
                             Name="ShowCountContextItem"
                             Header="Count: -"
-                            IsCheckable="True"/>
+                            IsCheckable="True" />
                         <MenuItem
                             Name="ShowMinContextItem"
                             Header="Min: -"
-                            IsCheckable="True"/>
+                            IsCheckable="True" />
                         <MenuItem
                             Name="ShowMaxContextItem"
                             Header="Max: -"
-                            IsCheckable="True"/>
+                            IsCheckable="True" />
                         <MenuItem
                             Name="ShowProductContextItem"
                             Header="Product: -"
-                            IsCheckable="True"/>
+                            IsCheckable="True" />
                     </ContextMenu>
                 </TextBox.ContextMenu>
             </TextBox>
@@ -715,31 +702,31 @@
                         <MenuItem
                             Name="AggregateSumContextItem"
                             Header="Sum: -"
-                            IsCheckable="True"/>
+                            IsCheckable="True" />
                         <MenuItem
                             Name="AggregateAverageContextItem"
                             Header="Average: -"
-                            IsCheckable="True"/>
+                            IsCheckable="True" />
                         <MenuItem
                             Name="AggregateMedianContextItem"
                             Header="Median: -"
-                            IsCheckable="True"/>
+                            IsCheckable="True" />
                         <MenuItem
                             Name="AggregateCountContextItem"
                             Header="Count: -"
-                            IsCheckable="True"/>
+                            IsCheckable="True" />
                         <MenuItem
                             Name="AggregateMinContextItem"
                             Header="Min: -"
-                            IsCheckable="True"/>
+                            IsCheckable="True" />
                         <MenuItem
                             Name="AggregateMaxContextItem"
                             Header="Max: -"
-                            IsCheckable="True"/>
+                            IsCheckable="True" />
                         <MenuItem
                             Name="AggregateProductContextItem"
                             Header="Product: -"
-                            IsCheckable="True"/>
+                            IsCheckable="True" />
                     </ContextMenu>
                 </Border.ContextMenu>
                 <Grid>
@@ -747,7 +734,7 @@
                         x:Name="CalcAggregateStatusText"
                         FontSize="12"
                         Foreground="{DynamicResource TextFillColorSecondaryBrush}"
-                        Text=""/>
+                        Text="" />
                     <ui:SymbolIcon
                         x:Name="CalcAggregateCopyIcon"
                         HorizontalAlignment="Center"
@@ -755,7 +742,7 @@
                         FontSize="16"
                         Foreground="{DynamicResource TextFillColorPrimaryBrush}"
                         Opacity="0"
-                        Symbol="Copy24"/>
+                        Symbol="Copy24" />
                 </Grid>
             </Border>
 
@@ -775,8 +762,7 @@
                     BorderThickness="0"
                     Click="CalcCopyAllButton_Click"
                     ToolTip="Copy All Results">
-                    <ui:SymbolIcon FontSize="14"
-                            Symbol="Copy24"/>
+                    <ui:SymbolIcon FontSize="14" Symbol="Copy24" />
                 </Button>
                 <Button
                     x:Name="CalcInfoButton"
@@ -787,8 +773,7 @@
                     BorderThickness="0"
                     Click="CalcInfoButton_Click"
                     ToolTip="Calculation Pane Help">
-                    <ui:SymbolIcon FontSize="14"
-                            Symbol="Info24"/>
+                    <ui:SymbolIcon FontSize="14" Symbol="Info24" />
                 </Button>
             </StackPanel>
 
@@ -810,62 +795,55 @@
                             Margin="0,0,0,8"
                             FontSize="16"
                             FontWeight="Bold"
-                            Text="Calculation Pane"/>
-                        <TextBlock Margin="0,0,0,8"
-                                TextWrapping="Wrap">
-                            <Run Text="Type mathematical expressions in the text area and see results calculated in real-time."/>
+                            Text="Calculation Pane" />
+                        <TextBlock Margin="0,0,0,8" TextWrapping="Wrap">
+                            <Run Text="Type mathematical expressions in the text area and see results calculated in real-time." />
                         </TextBlock>
                         <TextBlock
                             Margin="0,0,0,4"
                             FontWeight="SemiBold"
-                            Text="Features:"/>
-                        <TextBlock Margin="0,0,0,4"
-                                TextWrapping="Wrap">
-                            <Run Text="• Basic math: +, -, *, /, %, ** for exponent"/>
+                            Text="Features:" />
+                        <TextBlock Margin="0,0,0,4" TextWrapping="Wrap">
+                            <Run Text="• Basic math: +, -, *, /, %, ** for exponent" />
                         </TextBlock>
-                        <TextBlock Margin="0,0,0,4"
-                                TextWrapping="Wrap">
-                            <Run Text="• Functions: sin, cos, tan, sqrt, abs, log, etc."/>
+                        <TextBlock Margin="0,0,0,4" TextWrapping="Wrap">
+                            <Run Text="• Functions: sin, cos, tan, sqrt, abs, log, etc." />
                         </TextBlock>
-                        <TextBlock Margin="0,0,0,4"
-                                TextWrapping="Wrap">
-                            <Run Text="• Variables: x = 10"/>
+                        <TextBlock Margin="0,0,0,4" TextWrapping="Wrap">
+                            <Run Text="• Variables: x = 10" />
                         </TextBlock>
-                        <TextBlock Margin="0,0,0,4"
-                                TextWrapping="Wrap">
-                            <Run Text="• Constants: pi, e, tau, phi, sqrt2, sqrt3, sqrt5, ln2, ln10, log2e, log10e"/>
+                        <TextBlock Margin="0,0,0,4" TextWrapping="Wrap">
+                            <Run Text="• Constants: pi, e, tau, phi, sqrt2, sqrt3, sqrt5, ln2, ln10, log2e, log10e" />
                         </TextBlock>
-                        <TextBlock Margin="0,0,0,4"
-                                TextWrapping="Wrap">
-                            <Run Text="• Unit conversion: 5 miles to km, 100°F to celsius"/>
+                        <TextBlock Margin="0,0,0,4" TextWrapping="Wrap">
+                            <Run Text="• Unit conversion: 5 miles to km, 100°F to celsius" />
                         </TextBlock>
-                        <TextBlock Margin="0,0,0,4"
-                                TextWrapping="Wrap">
-                            <Run Text="• Supported units: length, mass, temperature, volume, speed, area"/>
+                        <TextBlock Margin="0,0,0,4" TextWrapping="Wrap">
+                            <Run Text="• Supported units: length, mass, temperature, volume, speed, area" />
                         </TextBlock>
                         <TextBlock
                             Margin="0,0,0,4"
                             FontWeight="SemiBold"
-                            Text="Examples:"/>
+                            Text="Examples:" />
                         <TextBlock
                             Margin="0,0,0,4"
                             FontFamily="Consolas"
                             FontSize="12"
                             TextWrapping="Wrap">
-                            <Run Text="x = 10"/><LineBreak/>
-                            <Run Text="y = 20"/><LineBreak/>
-                            <Run Text="x + y"/><LineBreak/>
-                            <Run Text="sin(pi/2)"/><LineBreak/>
-                            <Run Text="sqrt(x * y)"/>
+                            <Run Text="x = 10" /><LineBreak />
+                            <Run Text="y = 20" /><LineBreak />
+                            <Run Text="x + y" /><LineBreak />
+                            <Run Text="sin(pi/2)" /><LineBreak />
+                            <Run Text="sqrt(x * y)" />
                         </TextBlock>
                         <TextBlock
                             Margin="0,4,0,4"
                             FontFamily="Consolas"
                             FontSize="12"
                             TextWrapping="Wrap">
-                            <Run Text="5 miles to km"/><LineBreak/>
-                            <Run Text="100 fahrenheit to celsius"/><LineBreak/>
-                            <Run Text="3.5 gallons to liters"/>
+                            <Run Text="5 miles to km" /><LineBreak />
+                            <Run Text="100 fahrenheit to celsius" /><LineBreak />
+                            <Run Text="3.5 gallons to liters" />
                         </TextBlock>
                         <TextBlock
                             Margin="0,8,0,4"
@@ -873,20 +851,20 @@
                             FontWeight="SemiBold"
                             Foreground="{DynamicResource TextFillColorSecondaryBrush}"
                             Text="Note:"
-                            TextWrapping="Wrap"/>
+                            TextWrapping="Wrap" />
                         <TextBlock
                             Margin="0,0,0,8"
                             FontSize="11"
                             Foreground="{DynamicResource TextFillColorSecondaryBrush}"
                             TextWrapping="Wrap">
-                            <Run Text="Text wrapping is automatically disabled when the calculation pane is visible to ensure calculation results align vertically with their corresponding input lines."/>
+                            <Run Text="Text wrapping is automatically disabled when the calculation pane is visible to ensure calculation results align vertically with their corresponding input lines." />
                         </TextBlock>
                         <TextBlock
                             Margin="0,0,0,0"
                             FontSize="11"
                             Foreground="{DynamicResource TextFillColorSecondaryBrush}"
                             TextWrapping="Wrap">
-                            <Run Text="Toggle with Ctrl+P or the calculator button"/>
+                            <Run Text="Toggle with Ctrl+P or the calculator button" />
                         </TextBlock>
                     </StackPanel>
                 </Border>
@@ -901,7 +879,7 @@
                 Background="{DynamicResource SolidBackgroundFillColorBaseBrush}"
                 MouseDoubleClick="TextBoxSplitter_MouseDoubleClick"
                 ResizeDirection="Auto"
-                ShowsPreview="True"/>
+                ShowsPreview="True" />
 
             <!--  Subtle shadow at the edge of the calc pane/splitter for visual separation  -->
             <Rectangle
@@ -913,13 +891,10 @@
                 Panel.ZIndex="100"
                 IsHitTestVisible="False">
                 <Rectangle.Fill>
-                    <LinearGradientBrush StartPoint="0,0"
-                            EndPoint="1,0">
+                    <LinearGradientBrush StartPoint="0,0" EndPoint="1,0">
                         <!--  Slight shadow cast toward the calc pane area  -->
-                        <GradientStop Offset="0"
-                                Color="#33000000"/>
-                        <GradientStop Offset="1"
-                                Color="#00000000"/>
+                        <GradientStop Offset="0" Color="#33000000" />
+                        <GradientStop Offset="1" Color="#00000000" />
                     </LinearGradientBrush>
                 </Rectangle.Fill>
             </Rectangle>
@@ -937,13 +912,13 @@
                 Grid.Row="2"
                 Background="Transparent">
                 <Grid.ColumnDefinitions>
-                    <ColumnDefinition Width="auto"/>
-                    <ColumnDefinition Width="*"/>
+                    <ColumnDefinition Width="auto" />
+                    <ColumnDefinition Width="*" />
                 </Grid.ColumnDefinitions>
                 <StackPanel
                     Name="BottomBarButtons"
                     Margin="8,0"
-                    Orientation="Horizontal"/>
+                    Orientation="Horizontal" />
                 <StackPanel
                     Grid.Column="1"
                     Margin="20,0,20,0"
@@ -963,7 +938,7 @@
                         <TextBlock
                             FontFamily="Cascadia Mono"
                             FontSize="12"
-                            Text="0 matches"/>
+                            Text="0 matches" />
                     </Button>
                     <Button
                         x:Name="SimilarMatchesButton"
@@ -980,17 +955,17 @@
                         <TextBlock
                             FontFamily="Cascadia Mono"
                             FontSize="12"
-                            Text="0 similar"/>
+                            Text="0 similar" />
                         <Button.ContextMenu>
                             <ContextMenu>
                                 <MenuItem
                                     x:Name="SavePatternMenuItem"
                                     Click="SavePatternMenuItem_Click"
-                                    Header="Save Pattern"/>
+                                    Header="Save Pattern" />
                                 <MenuItem
                                     x:Name="ExplainPatternMenuItem"
                                     Click="ExplainPatternMenuItem_Click"
-                                    Header="Explain Pattern"/>
+                                    Header="Explain Pattern" />
                             </ContextMenu>
                         </Button.ContextMenu>
                     </Button>
@@ -1009,17 +984,17 @@
                         <TextBlock
                             FontFamily="Cascadia Mono"
                             FontSize="12"
-                            Text="Regex: "/>
+                            Text="Regex: " />
                         <Button.ContextMenu>
                             <ContextMenu>
                                 <MenuItem
                                     x:Name="SavePatternMenuItem2"
                                     Click="SavePatternMenuItem_Click"
-                                    Header="Save Pattern"/>
+                                    Header="Save Pattern" />
                                 <MenuItem
                                     x:Name="ExplainPatternMenuItem2"
                                     Click="ExplainPatternMenuItem_Click"
-                                    Header="Explain Pattern"/>
+                                    Header="Explain Pattern" />
                             </ContextMenu>
                         </Button.ContextMenu>
                     </Button>
@@ -1037,12 +1012,12 @@
                             x:Name="CharDetailsButtonText"
                             FontFamily="Cascadia Mono"
                             FontSize="12"
-                            Text="U+0000"/>
+                            Text="U+0000" />
                     </Button>
                     <TextBlock
                         x:Name="BottomBarText"
                         FontFamily="Cascadia Mono"
-                        Text="Ln 1, Col 0"/>
+                        Text="Ln 1, Col 0" />
                 </StackPanel>
                 <Popup
                     x:Name="CharDetailsPopup"
@@ -1057,14 +1032,12 @@
                         BorderBrush="{DynamicResource ControlStrongStrokeColorDefaultBrush}"
                         BorderThickness="1"
                         CornerRadius="4">
-                        <StackPanel x:Name="CharDetailsPopupContent"
-                                Width="300"/>
+                        <StackPanel x:Name="CharDetailsPopupContent" Width="300" />
                     </Border>
                 </Popup>
                 <Grid.ContextMenu>
                     <ContextMenu>
-                        <MenuItem Click="EditBottomBarMenuItem_Click"
-                                Header="Edit Bottom Bar"/>
+                        <MenuItem Click="EditBottomBarMenuItem_Click" Header="Edit Bottom Bar" />
                     </ContextMenu>
                 </Grid.ContextMenu>
             </Grid>
@@ -1080,14 +1053,14 @@
                 x:Name="ProgressRing"
                 Width="60"
                 Height="60"
-                IsIndeterminate="True"/>
+                IsIndeterminate="True" />
             <TextBlock
                 x:Name="ProgressText"
                 Margin="0,12,0,0"
                 FontSize="16"
                 FontWeight="Bold"
                 Foreground="{DynamicResource TextFillColorPrimaryBrush}"
-                Text="Working..."/>
+                Text="Working..." />
         </StackPanel>
     </Grid>
 </ui:FluentWindow>
diff --git a/Text-Grab/Views/EditTextWindow.xaml.cs b/Text-Grab/Views/EditTextWindow.xaml.cs
index 854029c6..83015ca0 100644
--- a/Text-Grab/Views/EditTextWindow.xaml.cs
+++ b/Text-Grab/Views/EditTextWindow.xaml.cs
@@ -913,6 +913,12 @@ private void GrabFrameMenuItem_Click(object sender, RoutedEventArgs e)
         CheckForGrabFrameOrLaunch();
     }
 
+    private void ManageGrabTemplates_Click(object sender, RoutedEventArgs e)
+    {
+        PostGrabActionEditor editor = new();
+        editor.Show();
+    }
+
     private void HandlePreviewMouseWheel(object sender, MouseWheelEventArgs e)
     {
         // Source: StackOverflow, read on Sep. 10, 2021
diff --git a/Text-Grab/Views/FullscreenGrab.SelectionStyles.cs b/Text-Grab/Views/FullscreenGrab.SelectionStyles.cs
new file mode 100644
index 00000000..ef17d018
--- /dev/null
+++ b/Text-Grab/Views/FullscreenGrab.SelectionStyles.cs
@@ -0,0 +1,1290 @@
+using Dapplo.Windows.User32;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Interop;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Shapes;
+using System.Windows.Threading;
+using Text_Grab.Extensions;
+using Text_Grab.Interfaces;
+using Text_Grab.Models;
+using Text_Grab.Services;
+using Text_Grab.Utilities;
+using Bitmap = System.Drawing.Bitmap;
+using Point = System.Windows.Point;
+
+namespace Text_Grab.Views;
+
+public partial class FullscreenGrab
+{
+    private enum SelectionInteractionMode
+    {
+        None = 0,
+        CreatingRectangle = 1,
+        CreatingFreeform = 2,
+        MovingSelection = 3,
+        ResizeLeft = 4,
+        ResizeTop = 5,
+        ResizeRight = 6,
+        ResizeBottom = 7,
+        ResizeTopLeft = 8,
+        ResizeTopRight = 9,
+        ResizeBottomLeft = 10,
+        ResizeBottomRight = 11,
+    }
+
+    private const double MinimumSelectionSize = 6.0;
+    private const double AdjustHandleSize = 12.0;
+    private static readonly SolidColorBrush SelectionBorderBrush = new(System.Windows.Media.Color.FromArgb(255, 40, 118, 126));
+    private static readonly SolidColorBrush WindowSelectionFillBrush = new(System.Windows.Media.Color.FromArgb(52, 255, 255, 255));
+    private static readonly SolidColorBrush WindowSelectionLabelBackgroundBrush = new(System.Windows.Media.Color.FromArgb(224, 20, 27, 46));
+    private static readonly SolidColorBrush FreeformFillBrush = new(System.Windows.Media.Color.FromArgb(36, 40, 118, 126));
+    private readonly DispatcherTimer windowSelectionTimer = new() { Interval = TimeSpan.FromMilliseconds(100) };
+    private readonly Path freeformSelectionPath = new()
+    {
+        Stroke = SelectionBorderBrush,
+        Fill = FreeformFillBrush,
+        StrokeThickness = 2,
+        Visibility = Visibility.Collapsed,
+        IsHitTestVisible = false
+    };
+
+    private readonly List<Point> freeformSelectionPoints = [];
+    private readonly List<Border> selectionHandleBorders = [];
+    private readonly Border selectionOutlineBorder = new();
+    private readonly Grid windowSelectionHighlightContent = new() { ClipToBounds = false, IsHitTestVisible = false };
+    private readonly Border windowSelectionInfoBadge = new();
+    private readonly TextBlock windowSelectionAppNameText = new();
+    private readonly TextBlock windowSelectionTitleText = new();
+    private Point adjustmentStartPoint = new();
+    private Rect selectionRectBeforeDrag = Rect.Empty;
+    private WindowSelectionCandidate? clickedWindowCandidate;
+    private WindowSelectionCandidate? hoveredWindowCandidate;
+    private SelectionInteractionMode selectionInteractionMode = SelectionInteractionMode.None;
+    private FsgSelectionStyle currentSelectionStyle = FsgSelectionStyle.Region;
+    private bool isAwaitingAdjustAfterCommit = false;
+    private bool suppressSelectionStyleComboBoxSelectionChanged = false;
+
+    private FsgSelectionStyle CurrentSelectionStyle => currentSelectionStyle;
+
+    private void InitializeSelectionStyles()
+    {
+        selectBorder.BorderThickness = new Thickness(2);
+        selectBorder.BorderBrush = SelectionBorderBrush;
+        selectBorder.Background = Brushes.Transparent;
+        selectBorder.CornerRadius = new CornerRadius(6);
+        selectBorder.IsHitTestVisible = false;
+        selectBorder.SnapsToDevicePixels = true;
+
+        selectionOutlineBorder.BorderThickness = new Thickness(2);
+        selectionOutlineBorder.BorderBrush = SelectionBorderBrush;
+        selectionOutlineBorder.Background = Brushes.Transparent;
+        selectionOutlineBorder.CornerRadius = new CornerRadius(0);
+        selectionOutlineBorder.IsHitTestVisible = false;
+        selectionOutlineBorder.SnapsToDevicePixels = true;
+
+        windowSelectionAppNameText.FontWeight = FontWeights.SemiBold;
+        windowSelectionAppNameText.Foreground = Brushes.White;
+        windowSelectionAppNameText.TextTrimming = TextTrimming.CharacterEllipsis;
+
+        windowSelectionTitleText.Margin = new Thickness(0, 2, 0, 0);
+        windowSelectionTitleText.Foreground = Brushes.White;
+        windowSelectionTitleText.TextTrimming = TextTrimming.CharacterEllipsis;
+        windowSelectionTitleText.TextWrapping = TextWrapping.NoWrap;
+
+        StackPanel windowSelectionTextStack = new()
+        {
+            MaxWidth = 360,
+            Orientation = Orientation.Vertical
+        };
+        windowSelectionTextStack.Children.Add(windowSelectionAppNameText);
+        windowSelectionTextStack.Children.Add(windowSelectionTitleText);
+
+        windowSelectionInfoBadge.Background = WindowSelectionLabelBackgroundBrush;
+        windowSelectionInfoBadge.CornerRadius = new CornerRadius(4);
+        windowSelectionInfoBadge.HorizontalAlignment = HorizontalAlignment.Left;
+        windowSelectionInfoBadge.Margin = new Thickness(8);
+        windowSelectionInfoBadge.Padding = new Thickness(8, 5, 8, 6);
+        windowSelectionInfoBadge.VerticalAlignment = VerticalAlignment.Top;
+        windowSelectionInfoBadge.Child = windowSelectionTextStack;
+
+        windowSelectionHighlightContent.Children.Add(windowSelectionInfoBadge);
+        windowSelectionTimer.Tick += WindowSelectionTimer_Tick;
+    }
+
+    private void ApplySelectionStyle(FsgSelectionStyle selectionStyle, bool persistToSettings = true)
+    {
+        currentSelectionStyle = selectionStyle;
+        SyncSelectionStyleComboBox(selectionStyle);
+
+        RegionSelectionMenuItem.IsChecked = selectionStyle == FsgSelectionStyle.Region;
+        WindowSelectionMenuItem.IsChecked = selectionStyle == FsgSelectionStyle.Window;
+        FreeformSelectionMenuItem.IsChecked = selectionStyle == FsgSelectionStyle.Freeform;
+        AdjustAfterSelectionMenuItem.IsChecked = selectionStyle == FsgSelectionStyle.AdjustAfter;
+
+        if (persistToSettings)
+        {
+            DefaultSettings.FsgSelectionStyle = selectionStyle.ToString();
+            DefaultSettings.Save();
+        }
+
+        ResetSelectionVisualState();
+        RegionClickCanvas.Cursor = selectionStyle == FsgSelectionStyle.Window ? Cursors.Hand : Cursors.Cross;
+        UpdateTopToolbarVisibility(RegionClickCanvas.IsMouseOver || TopButtonsStackPanel.IsMouseOver);
+
+        if (selectionStyle == FsgSelectionStyle.Window)
+            UpdateWindowSelectionHighlight();
+    }
+
+    internal static bool ShouldKeepTopToolbarVisible(FsgSelectionStyle selectionStyle, bool isAwaitingAdjustAfterCommit)
+    {
+        return selectionStyle == FsgSelectionStyle.Window || isAwaitingAdjustAfterCommit;
+    }
+
+    internal static bool ShouldCommitWindowSelection(WindowSelectionCandidate? pressedWindowCandidate, WindowSelectionCandidate? releasedWindowCandidate)
+    {
+        return pressedWindowCandidate is not null
+            && releasedWindowCandidate is not null
+            && pressedWindowCandidate.Handle == releasedWindowCandidate.Handle;
+    }
+
+    internal static bool ShouldUseOverlayCutout(FsgSelectionStyle selectionStyle)
+    {
+        return selectionStyle is FsgSelectionStyle.Region or FsgSelectionStyle.AdjustAfter;
+    }
+
+    internal static bool ShouldDrawSelectionOutline(FsgSelectionStyle selectionStyle)
+    {
+        return ShouldUseOverlayCutout(selectionStyle);
+    }
+
+    private static Key GetSelectionStyleKey(FsgSelectionStyle selectionStyle)
+    {
+        return selectionStyle switch
+        {
+            FsgSelectionStyle.Region => Key.R,
+            FsgSelectionStyle.Window => Key.W,
+            FsgSelectionStyle.Freeform => Key.D,
+            FsgSelectionStyle.AdjustAfter => Key.A,
+            _ => Key.R,
+        };
+    }
+
+    private bool TryGetSelectionStyle(object? sender, out FsgSelectionStyle selectionStyle)
+    {
+        selectionStyle = FsgSelectionStyle.Region;
+        if (sender is not FrameworkElement element || element.Tag is not string tag)
+            return false;
+
+        return Enum.TryParse(tag, true, out selectionStyle);
+    }
+
+    private void SelectionStyleMenuItem_Click(object sender, RoutedEventArgs e)
+    {
+        if (TryGetSelectionStyle(sender, out FsgSelectionStyle selectionStyle))
+            WindowUtilities.FullscreenKeyDown(GetSelectionStyleKey(selectionStyle));
+    }
+
+    private void SelectionStyleComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
+    {
+        if (suppressSelectionStyleComboBoxSelectionChanged
+            || SelectionStyleComboBox.SelectedItem is not ComboBoxItem selectedItem)
+            return;
+
+        if (TryGetSelectionStyle(selectedItem, out FsgSelectionStyle selectionStyle))
+            WindowUtilities.FullscreenKeyDown(GetSelectionStyleKey(selectionStyle));
+    }
+
+    private void SyncSelectionStyleComboBox(FsgSelectionStyle selectionStyle)
+    {
+        suppressSelectionStyleComboBoxSelectionChanged = true;
+
+        try
+        {
+            foreach (ComboBoxItem comboBoxItem in SelectionStyleComboBox.Items.OfType<ComboBoxItem>())
+            {
+                if (!TryGetSelectionStyle(comboBoxItem, out FsgSelectionStyle comboBoxItemStyle))
+                    continue;
+
+                if (comboBoxItemStyle == selectionStyle)
+                {
+                    SelectionStyleComboBox.SelectedItem = comboBoxItem;
+                    return;
+                }
+            }
+
+            SelectionStyleComboBox.SelectedIndex = -1;
+        }
+        finally
+        {
+            suppressSelectionStyleComboBoxSelectionChanged = false;
+        }
+    }
+
+    private void WindowSelectionTimer_Tick(object? sender, EventArgs e)
+    {
+        if (CurrentSelectionStyle != FsgSelectionStyle.Window || selectionInteractionMode != SelectionInteractionMode.None)
+        {
+            if (hoveredWindowCandidate is not null)
+            {
+                hoveredWindowCandidate = null;
+                clickedWindowCandidate = null;
+                ClearSelectionBorderVisual();
+            }
+
+            return;
+        }
+
+        UpdateWindowSelectionHighlight();
+    }
+
+    private void UpdateWindowSelectionHighlight()
+    {
+        ApplyWindowSelectionHighlight(GetWindowSelectionCandidateAtCurrentMousePosition());
+    }
+
+    private void UpdateTopToolbarVisibility(bool isPointerOverSelectionSurface)
+    {
+        if (ShouldKeepTopToolbarVisible(CurrentSelectionStyle, isAwaitingAdjustAfterCommit))
+        {
+            TopButtonsStackPanel.Visibility = Visibility.Visible;
+            return;
+        }
+
+        if (isSelecting)
+        {
+            TopButtonsStackPanel.Visibility = Visibility.Collapsed;
+            return;
+        }
+
+        TopButtonsStackPanel.Visibility = isPointerOverSelectionSurface
+            ? Visibility.Visible
+            : Visibility.Collapsed;
+    }
+
+    private WindowSelectionCandidate? GetWindowSelectionCandidateAtCurrentMousePosition()
+    {
+        if (!WindowUtilities.GetMousePosition(out Point mousePosition))
+            return null;
+
+        return WindowSelectionUtilities.FindWindowAtPoint(
+            WindowSelectionUtilities.GetCapturableWindows(GetExcludedWindowHandles()),
+            mousePosition);
+    }
+
+    private void ApplyWindowSelectionHighlight(WindowSelectionCandidate? candidate)
+    {
+        hoveredWindowCandidate = candidate;
+
+        if (candidate is null)
+        {
+            ClearSelectionBorderVisual();
+            return;
+        }
+
+        Rect windowBounds = GetWindowDeviceBounds();
+        Rect intersection = Rect.Intersect(candidate.Bounds, windowBounds);
+        if (intersection == Rect.Empty)
+        {
+            ClearSelectionBorderVisual();
+            return;
+        }
+
+        Rect localRect = ConvertAbsoluteDeviceRectToLocal(intersection);
+        ApplySelectionRect(localRect, WindowSelectionFillBrush, updateTemplateOverlays: false);
+        UpdateWindowSelectionInfo(candidate, localRect);
+    }
+
+    private IReadOnlyCollection<IntPtr> GetExcludedWindowHandles()
+    {
+        List<IntPtr> handles = [];
+        foreach (Window window in Application.Current.Windows)
+        {
+            IntPtr handle = new WindowInteropHelper(window).Handle;
+            if (handle != IntPtr.Zero)
+                handles.Add(handle);
+        }
+
+        return handles;
+    }
+
+    private double GetCurrentDeviceScale()
+    {
+        PresentationSource? presentationSource = PresentationSource.FromVisual(this);
+        return presentationSource?.CompositionTarget is null
+            ? 1.0
+            : presentationSource.CompositionTarget.TransformToDevice.M11;
+    }
+
+    private Rect GetWindowDeviceBounds()
+    {
+        DpiScale dpi = VisualTreeHelper.GetDpi(this);
+        Point absolutePosition = this.GetAbsolutePosition();
+        return new Rect(absolutePosition.X, absolutePosition.Y, ActualWidth * dpi.DpiScaleX, ActualHeight * dpi.DpiScaleY);
+    }
+
+    private Rect ConvertAbsoluteDeviceRectToLocal(Rect absoluteRect)
+    {
+        PresentationSource? presentationSource = PresentationSource.FromVisual(this);
+        if (presentationSource?.CompositionTarget is null)
+            return Rect.Empty;
+
+        Point absoluteWindowPosition = this.GetAbsolutePosition();
+        Matrix fromDevice = presentationSource.CompositionTarget.TransformFromDevice;
+
+        Point topLeft = fromDevice.Transform(new Point(
+            absoluteRect.Left - absoluteWindowPosition.X,
+            absoluteRect.Top - absoluteWindowPosition.Y));
+
+        Point bottomRight = fromDevice.Transform(new Point(
+            absoluteRect.Right - absoluteWindowPosition.X,
+            absoluteRect.Bottom - absoluteWindowPosition.Y));
+
+        return new Rect(topLeft, bottomRight);
+    }
+
+    private Rect GetCurrentSelectionRect()
+    {
+        double left = Canvas.GetLeft(selectBorder);
+        double top = Canvas.GetTop(selectBorder);
+
+        if (double.IsNaN(left) || double.IsNaN(top))
+            return Rect.Empty;
+
+        return new Rect(left, top, selectBorder.Width, selectBorder.Height);
+    }
+
+    private void ApplySelectionRect(
+        Rect rect,
+        Brush? selectionFillBrush = null,
+        bool updateTemplateOverlays = true,
+        bool? useOverlayCutout = null)
+    {
+        EnsureSelectionBorderVisible();
+        bool shouldUseCutout = useOverlayCutout ?? ShouldUseOverlayCutout(CurrentSelectionStyle);
+
+        selectBorder.Width = Math.Max(0, rect.Width);
+        selectBorder.Height = Math.Max(0, rect.Height);
+        selectBorder.Background = selectionFillBrush ?? Brushes.Transparent;
+        Canvas.SetLeft(selectBorder, rect.Left);
+        Canvas.SetTop(selectBorder, rect.Top);
+        clippingGeometry.Rect = shouldUseCutout
+            ? rect
+            : Rect.Empty;
+        UpdateSelectionOutline(rect, shouldUseCutout && ShouldDrawSelectionOutline(CurrentSelectionStyle));
+
+        if (updateTemplateOverlays)
+            UpdateTemplateRegionOverlays(rect.Left, rect.Top, rect.Width, rect.Height);
+    }
+
+    private void UpdateWindowSelectionInfo(WindowSelectionCandidate candidate, Rect localRect)
+    {
+        windowSelectionAppNameText.Text = candidate.DisplayAppName;
+        windowSelectionTitleText.Text = candidate.DisplayTitle;
+        windowSelectionInfoBadge.MaxWidth = Math.Max(72, localRect.Width - 16);
+        selectBorder.Child = windowSelectionHighlightContent;
+    }
+
+    private void EnsureSelectionBorderVisible()
+    {
+        if (!RegionClickCanvas.Children.Contains(selectBorder))
+            _ = RegionClickCanvas.Children.Add(selectBorder);
+    }
+
+    private void EnsureSelectionOutlineVisible()
+    {
+        if (!SelectionOutlineHost.Children.Contains(selectionOutlineBorder))
+            _ = SelectionOutlineHost.Children.Add(selectionOutlineBorder);
+    }
+
+    private void ClearSelectionBorderVisual()
+    {
+        if (RegionClickCanvas.Children.Contains(selectBorder))
+            RegionClickCanvas.Children.Remove(selectBorder);
+
+        ClearSelectionOutline();
+        selectBorder.Background = Brushes.Transparent;
+        selectBorder.Child = null;
+        clippingGeometry.Rect = new Rect(new Point(0, 0), new Size(0, 0));
+        TemplateOverlayHost.Children.Clear();
+        templateOverlayCanvas.Children.Clear();
+    }
+
+    private void UpdateSelectionOutline(Rect rect, bool shouldShowOutline)
+    {
+        if (!shouldShowOutline || rect.Width <= 0 || rect.Height <= 0)
+        {
+            ClearSelectionOutline();
+            return;
+        }
+
+        EnsureSelectionOutlineVisible();
+        selectionOutlineBorder.Width = Math.Max(0, rect.Width);
+        selectionOutlineBorder.Height = Math.Max(0, rect.Height);
+        Canvas.SetLeft(selectionOutlineBorder, rect.Left);
+        Canvas.SetTop(selectionOutlineBorder, rect.Top);
+    }
+
+    private void ClearSelectionOutline()
+    {
+        if (SelectionOutlineHost.Children.Contains(selectionOutlineBorder))
+            SelectionOutlineHost.Children.Remove(selectionOutlineBorder);
+    }
+
+    private void ResetSelectionVisualState()
+    {
+        isSelecting = false;
+        isShiftDown = false;
+        isAwaitingAdjustAfterCommit = false;
+        selectionInteractionMode = SelectionInteractionMode.None;
+        clickedWindowCandidate = null;
+        hoveredWindowCandidate = null;
+        CurrentScreen = null;
+
+        CursorClipper.UnClipCursor();
+        RegionClickCanvas.ReleaseMouseCapture();
+
+        ClearSelectionBorderVisual();
+        ClearFreeformSelection();
+        ClearSelectionHandles();
+
+        AcceptSelectionButton.Visibility = Visibility.Collapsed;
+    }
+
+    private void ClearFreeformSelection()
+    {
+        freeformSelectionPoints.Clear();
+        freeformSelectionPath.Visibility = Visibility.Collapsed;
+
+        if (RegionClickCanvas.Children.Contains(freeformSelectionPath))
+            RegionClickCanvas.Children.Remove(freeformSelectionPath);
+    }
+
+    private void EnsureFreeformSelectionPath()
+    {
+        if (!RegionClickCanvas.Children.Contains(freeformSelectionPath))
+            _ = RegionClickCanvas.Children.Add(freeformSelectionPath);
+
+        freeformSelectionPath.Visibility = Visibility.Visible;
+    }
+
+    private void ClearSelectionHandles()
+    {
+        foreach (Border handleBorder in selectionHandleBorders)
+            RegionClickCanvas.Children.Remove(handleBorder);
+
+        selectionHandleBorders.Clear();
+    }
+
+    private void UpdateSelectionHandles()
+    {
+        ClearSelectionHandles();
+
+        if (!isAwaitingAdjustAfterCommit)
+            return;
+
+        Rect selectionRect = GetCurrentSelectionRect();
+        if (selectionRect == Rect.Empty)
+            return;
+
+        foreach (SelectionInteractionMode handle in new[]
+        {
+            SelectionInteractionMode.ResizeTopLeft,
+            SelectionInteractionMode.ResizeTop,
+            SelectionInteractionMode.ResizeTopRight,
+            SelectionInteractionMode.ResizeRight,
+            SelectionInteractionMode.ResizeBottomRight,
+            SelectionInteractionMode.ResizeBottom,
+            SelectionInteractionMode.ResizeBottomLeft,
+            SelectionInteractionMode.ResizeLeft,
+        })
+        {
+            Rect handleRect = GetHandleRect(selectionRect, handle);
+            Border handleBorder = new()
+            {
+                Width = handleRect.Width,
+                Height = handleRect.Height,
+                Background = SelectionBorderBrush,
+                BorderBrush = Brushes.White,
+                BorderThickness = new Thickness(1),
+                CornerRadius = new CornerRadius(2),
+                IsHitTestVisible = false
+            };
+
+            selectionHandleBorders.Add(handleBorder);
+            _ = RegionClickCanvas.Children.Add(handleBorder);
+            Canvas.SetLeft(handleBorder, handleRect.Left);
+            Canvas.SetTop(handleBorder, handleRect.Top);
+        }
+    }
+
+    private Rect GetHandleRect(Rect selectionRect, SelectionInteractionMode handle)
+    {
+        double halfHandle = AdjustHandleSize / 2.0;
+        return handle switch
+        {
+            SelectionInteractionMode.ResizeTopLeft => new Rect(selectionRect.Left - halfHandle, selectionRect.Top - halfHandle, AdjustHandleSize, AdjustHandleSize),
+            SelectionInteractionMode.ResizeTop => new Rect(selectionRect.Left + (selectionRect.Width / 2.0) - halfHandle, selectionRect.Top - halfHandle, AdjustHandleSize, AdjustHandleSize),
+            SelectionInteractionMode.ResizeTopRight => new Rect(selectionRect.Right - halfHandle, selectionRect.Top - halfHandle, AdjustHandleSize, AdjustHandleSize),
+            SelectionInteractionMode.ResizeRight => new Rect(selectionRect.Right - halfHandle, selectionRect.Top + (selectionRect.Height / 2.0) - halfHandle, AdjustHandleSize, AdjustHandleSize),
+            SelectionInteractionMode.ResizeBottomRight => new Rect(selectionRect.Right - halfHandle, selectionRect.Bottom - halfHandle, AdjustHandleSize, AdjustHandleSize),
+            SelectionInteractionMode.ResizeBottom => new Rect(selectionRect.Left + (selectionRect.Width / 2.0) - halfHandle, selectionRect.Bottom - halfHandle, AdjustHandleSize, AdjustHandleSize),
+            SelectionInteractionMode.ResizeBottomLeft => new Rect(selectionRect.Left - halfHandle, selectionRect.Bottom - halfHandle, AdjustHandleSize, AdjustHandleSize),
+            SelectionInteractionMode.ResizeLeft => new Rect(selectionRect.Left - halfHandle, selectionRect.Top + (selectionRect.Height / 2.0) - halfHandle, AdjustHandleSize, AdjustHandleSize),
+            _ => Rect.Empty,
+        };
+    }
+
+    private SelectionInteractionMode GetSelectionInteractionModeForPoint(Point point)
+    {
+        Rect selectionRect = GetCurrentSelectionRect();
+        if (selectionRect == Rect.Empty)
+            return SelectionInteractionMode.None;
+
+        foreach (SelectionInteractionMode handle in new[]
+        {
+            SelectionInteractionMode.ResizeTopLeft,
+            SelectionInteractionMode.ResizeTopRight,
+            SelectionInteractionMode.ResizeBottomRight,
+            SelectionInteractionMode.ResizeBottomLeft,
+            SelectionInteractionMode.ResizeTop,
+            SelectionInteractionMode.ResizeRight,
+            SelectionInteractionMode.ResizeBottom,
+            SelectionInteractionMode.ResizeLeft,
+        })
+        {
+            if (GetHandleRect(selectionRect, handle).Contains(point))
+                return handle;
+        }
+
+        return selectionRect.Contains(point)
+            ? SelectionInteractionMode.MovingSelection
+            : SelectionInteractionMode.None;
+    }
+
+    private static Cursor GetCursorForInteractionMode(SelectionInteractionMode mode)
+    {
+        return mode switch
+        {
+            SelectionInteractionMode.MovingSelection => Cursors.SizeAll,
+            SelectionInteractionMode.ResizeLeft => Cursors.SizeWE,
+            SelectionInteractionMode.ResizeRight => Cursors.SizeWE,
+            SelectionInteractionMode.ResizeTop => Cursors.SizeNS,
+            SelectionInteractionMode.ResizeBottom => Cursors.SizeNS,
+            SelectionInteractionMode.ResizeTopLeft => Cursors.SizeNWSE,
+            SelectionInteractionMode.ResizeBottomRight => Cursors.SizeNWSE,
+            SelectionInteractionMode.ResizeTopRight => Cursors.SizeNESW,
+            SelectionInteractionMode.ResizeBottomLeft => Cursors.SizeNESW,
+            _ => Cursors.Cross,
+        };
+    }
+
+    private void UpdateAdjustAfterCursor(Point point)
+    {
+        if (!isAwaitingAdjustAfterCommit)
+            return;
+
+        SelectionInteractionMode interactionMode = GetSelectionInteractionModeForPoint(point);
+        RegionClickCanvas.Cursor = interactionMode == SelectionInteractionMode.None
+            ? Cursors.Cross
+            : GetCursorForInteractionMode(interactionMode);
+    }
+
+    private void BeginRectangleSelection(MouseEventArgs e)
+    {
+        ResetSelectionVisualState();
+        clickedPoint = e.GetPosition(this);
+        dpiScale = VisualTreeHelper.GetDpi(this);
+        selectionInteractionMode = SelectionInteractionMode.CreatingRectangle;
+        isSelecting = true;
+        TopButtonsStackPanel.Visibility = Visibility.Collapsed;
+        RegionClickCanvas.CaptureMouse();
+        CursorClipper.ClipCursor(this);
+        ApplySelectionRect(new Rect(clickedPoint, clickedPoint));
+        SetCurrentScreenFromMouse();
+    }
+
+    private void BeginFreeformSelection(MouseEventArgs e)
+    {
+        ResetSelectionVisualState();
+        selectionInteractionMode = SelectionInteractionMode.CreatingFreeform;
+        isSelecting = true;
+        TopButtonsStackPanel.Visibility = Visibility.Collapsed;
+        RegionClickCanvas.CaptureMouse();
+        CursorClipper.ClipCursor(this);
+
+        freeformSelectionPoints.Add(e.GetPosition(this));
+        EnsureFreeformSelectionPath();
+        freeformSelectionPath.Data = FreeformCaptureUtilities.BuildGeometry(freeformSelectionPoints);
+    }
+
+    private bool TryBeginAdjustAfterInteraction(MouseButtonEventArgs e)
+    {
+        if (!isAwaitingAdjustAfterCommit || !RegionClickCanvas.Children.Contains(selectBorder))
+            return false;
+
+        SelectionInteractionMode interactionMode = GetSelectionInteractionModeForPoint(e.GetPosition(this));
+        if (interactionMode == SelectionInteractionMode.None)
+            return false;
+
+        adjustmentStartPoint = e.GetPosition(this);
+        selectionRectBeforeDrag = GetCurrentSelectionRect();
+        selectionInteractionMode = interactionMode;
+        isSelecting = true;
+        RegionClickCanvas.CaptureMouse();
+        CursorClipper.ClipCursor(this);
+        return true;
+    }
+
+    private void SetCurrentScreenFromMouse()
+    {
+        WindowUtilities.GetMousePosition(out Point mousePoint);
+        foreach (DisplayInfo? screen in DisplayInfo.AllDisplayInfos)
+        {
+            Rect bound = screen.ScaledBounds();
+            if (bound.Contains(mousePoint))
+            {
+                CurrentScreen = screen;
+                break;
+            }
+        }
+    }
+
+    private void UpdateRectangleSelection(Point movingPoint)
+    {
+        if (Keyboard.Modifiers == ModifierKeys.Shift)
+        {
+            PanSelection(movingPoint);
+            return;
+        }
+
+        isShiftDown = false;
+
+        double left = Math.Min(clickedPoint.X, movingPoint.X);
+        double top = Math.Min(clickedPoint.Y, movingPoint.Y);
+        double width = Math.Abs(clickedPoint.X - movingPoint.X);
+        double height = Math.Abs(clickedPoint.Y - movingPoint.Y);
+
+        ApplySelectionRect(new Rect(left, top, width, height));
+    }
+
+    private void UpdateFreeformSelection(Point movingPoint)
+    {
+        if (freeformSelectionPoints.Count > 0 && (movingPoint - freeformSelectionPoints[^1]).Length < 2)
+            return;
+
+        freeformSelectionPoints.Add(movingPoint);
+        EnsureFreeformSelectionPath();
+        freeformSelectionPath.Data = FreeformCaptureUtilities.BuildGeometry(freeformSelectionPoints);
+    }
+
+    private void UpdateAdjustedSelection(Point movingPoint)
+    {
+        Rect surfaceRect = new(0, 0, RegionClickCanvas.ActualWidth, RegionClickCanvas.ActualHeight);
+        if (surfaceRect.Width <= 0 || surfaceRect.Height <= 0)
+            surfaceRect = new Rect(0, 0, ActualWidth, ActualHeight);
+
+        Rect updatedRect = selectionRectBeforeDrag;
+        if (selectionInteractionMode == SelectionInteractionMode.MovingSelection)
+        {
+            double newLeft = Math.Clamp(selectionRectBeforeDrag.Left + (movingPoint.X - adjustmentStartPoint.X), 0, Math.Max(0, surfaceRect.Width - selectionRectBeforeDrag.Width));
+            double newTop = Math.Clamp(selectionRectBeforeDrag.Top + (movingPoint.Y - adjustmentStartPoint.Y), 0, Math.Max(0, surfaceRect.Height - selectionRectBeforeDrag.Height));
+            updatedRect = new Rect(newLeft, newTop, selectionRectBeforeDrag.Width, selectionRectBeforeDrag.Height);
+        }
+        else
+        {
+            double left = selectionRectBeforeDrag.Left;
+            double top = selectionRectBeforeDrag.Top;
+            double right = selectionRectBeforeDrag.Right;
+            double bottom = selectionRectBeforeDrag.Bottom;
+
+            switch (selectionInteractionMode)
+            {
+                case SelectionInteractionMode.ResizeLeft:
+                case SelectionInteractionMode.ResizeTopLeft:
+                case SelectionInteractionMode.ResizeBottomLeft:
+                    left = Math.Clamp(movingPoint.X, 0, right - MinimumSelectionSize);
+                    break;
+            }
+
+            switch (selectionInteractionMode)
+            {
+                case SelectionInteractionMode.ResizeRight:
+                case SelectionInteractionMode.ResizeTopRight:
+                case SelectionInteractionMode.ResizeBottomRight:
+                    right = Math.Clamp(movingPoint.X, left + MinimumSelectionSize, surfaceRect.Width);
+                    break;
+            }
+
+            switch (selectionInteractionMode)
+            {
+                case SelectionInteractionMode.ResizeTop:
+                case SelectionInteractionMode.ResizeTopLeft:
+                case SelectionInteractionMode.ResizeTopRight:
+                    top = Math.Clamp(movingPoint.Y, 0, bottom - MinimumSelectionSize);
+                    break;
+            }
+
+            switch (selectionInteractionMode)
+            {
+                case SelectionInteractionMode.ResizeBottom:
+                case SelectionInteractionMode.ResizeBottomLeft:
+                case SelectionInteractionMode.ResizeBottomRight:
+                    bottom = Math.Clamp(movingPoint.Y, top + MinimumSelectionSize, surfaceRect.Height);
+                    break;
+            }
+
+            updatedRect = new Rect(new Point(left, top), new Point(right, bottom));
+        }
+
+        ApplySelectionRect(updatedRect);
+        UpdateSelectionHandles();
+    }
+
+    private void EndSelectionInteraction()
+    {
+        isSelecting = false;
+        CursorClipper.UnClipCursor();
+        RegionClickCanvas.ReleaseMouseCapture();
+        selectionInteractionMode = SelectionInteractionMode.None;
+        CurrentScreen = null;
+    }
+
+    private async Task FinalizeRectangleSelectionAsync()
+    {
+        EndSelectionInteraction();
+
+        Rect selectionRect = GetCurrentSelectionRect();
+        bool isSmallClick = selectionRect.Width < MinimumSelectionSize || selectionRect.Height < MinimumSelectionSize;
+
+        if (CurrentSelectionStyle == FsgSelectionStyle.AdjustAfter)
+        {
+            if (isSmallClick)
+            {
+                ResetSelectionVisualState();
+                TopButtonsStackPanel.Visibility = Visibility.Visible;
+                return;
+            }
+
+            EnterAdjustAfterMode();
+            return;
+        }
+
+        FullscreenCaptureResult selection = CreateRectangleSelectionResult(CurrentSelectionStyle);
+        await CommitSelectionAsync(selection, isSmallClick);
+    }
+
+    private async Task FinalizeFreeformSelectionAsync()
+    {
+        EndSelectionInteraction();
+
+        Rect bounds = FreeformCaptureUtilities.GetBounds(freeformSelectionPoints);
+        if (bounds == Rect.Empty || bounds.Width < MinimumSelectionSize || bounds.Height < MinimumSelectionSize)
+        {
+            ResetSelectionVisualState();
+            TopButtonsStackPanel.Visibility = Visibility.Visible;
+            return;
+        }
+
+        FullscreenCaptureResult? selection = CreateFreeformSelectionResult();
+        ResetSelectionVisualState();
+
+        if (selection is not null)
+            await CommitSelectionAsync(selection, false);
+    }
+
+    private FullscreenCaptureResult CreateRectangleSelectionResult(FsgSelectionStyle selectionStyle)
+    {
+        Rect selectionRect = GetCurrentSelectionRect();
+        PresentationSource? presentationSource = PresentationSource.FromVisual(this);
+        Matrix transformToDevice = presentationSource?.CompositionTarget?.TransformToDevice ?? Matrix.Identity;
+        Point absoluteWindowPosition = this.GetAbsolutePosition();
+
+        double left = Math.Round(selectionRect.Left * transformToDevice.M11);
+        double top = Math.Round(selectionRect.Top * transformToDevice.M22);
+        double width = Math.Max(1, Math.Round(selectionRect.Width * transformToDevice.M11));
+        double height = Math.Max(1, Math.Round(selectionRect.Height * transformToDevice.M22));
+
+        return new FullscreenCaptureResult(
+            selectionStyle,
+            new Rect(absoluteWindowPosition.X + left, absoluteWindowPosition.Y + top, width, height));
+    }
+
+    private FullscreenCaptureResult? CreateFreeformSelectionResult()
+    {
+        if (freeformSelectionPoints.Count < 3)
+            return null;
+
+        PresentationSource? presentationSource = PresentationSource.FromVisual(this);
+        Matrix transformToDevice = presentationSource?.CompositionTarget?.TransformToDevice ?? Matrix.Identity;
+        Point absoluteWindowPosition = this.GetAbsolutePosition();
+
+        List<Point> devicePoints = [.. freeformSelectionPoints.Select(point =>
+        {
+            Point devicePoint = transformToDevice.Transform(point);
+            return new Point(Math.Round(devicePoint.X), Math.Round(devicePoint.Y));
+        })];
+
+        Rect deviceBounds = FreeformCaptureUtilities.GetBounds(devicePoints);
+        if (deviceBounds == Rect.Empty)
+            return null;
+
+        Rect absoluteCaptureRect = new(
+            absoluteWindowPosition.X + deviceBounds.X,
+            absoluteWindowPosition.Y + deviceBounds.Y,
+            deviceBounds.Width,
+            deviceBounds.Height);
+
+        List<Point> relativePoints = [.. devicePoints.Select(point => new Point(point.X - deviceBounds.X, point.Y - deviceBounds.Y))];
+
+        using Bitmap rawBitmap = ImageMethods.GetRegionOfScreenAsBitmap(absoluteCaptureRect.AsRectangle(), cacheResult: false);
+        Bitmap maskedBitmap = FreeformCaptureUtilities.CreateMaskedBitmap(rawBitmap, relativePoints);
+        Singleton<HistoryService>.Instance.CacheLastBitmap(maskedBitmap);
+
+        BitmapSource captureImage = ImageMethods.BitmapToImageSource(maskedBitmap);
+
+        return new FullscreenCaptureResult(
+            FsgSelectionStyle.Freeform,
+            absoluteCaptureRect,
+            captureImage);
+    }
+
+    private FullscreenCaptureResult CreateWindowSelectionResult(WindowSelectionCandidate candidate)
+    {
+        BitmapSource? capturedImage = ComposeCapturedImageFromFullscreenBackgrounds(candidate.Bounds);
+        return new FullscreenCaptureResult(
+            FsgSelectionStyle.Window,
+            candidate.Bounds,
+            capturedImage,
+            candidate.Title);
+    }
+
+    private static BitmapSource? ComposeCapturedImageFromFullscreenBackgrounds(Rect absoluteCaptureRect)
+    {
+        if (Application.Current is null || absoluteCaptureRect.IsEmpty || absoluteCaptureRect.Width <= 0 || absoluteCaptureRect.Height <= 0)
+            return null;
+
+        int targetWidth = Math.Max(1, (int)Math.Ceiling(absoluteCaptureRect.Width));
+        int targetHeight = Math.Max(1, (int)Math.Ceiling(absoluteCaptureRect.Height));
+        int drawnSegments = 0;
+
+        DrawingVisual drawingVisual = new();
+        using (DrawingContext drawingContext = drawingVisual.RenderOpen())
+        {
+            drawingContext.DrawRectangle(Brushes.White, null, new Rect(0, 0, targetWidth, targetHeight));
+
+            foreach (FullscreenGrab fullscreenGrab in Application.Current.Windows.OfType<FullscreenGrab>())
+            {
+                if (fullscreenGrab.BackgroundImage.Source is not BitmapSource backgroundBitmap)
+                    continue;
+
+                Rect windowBounds = fullscreenGrab.GetWindowDeviceBounds();
+                Rect intersection = Rect.Intersect(windowBounds, absoluteCaptureRect);
+                if (intersection.IsEmpty || intersection.Width <= 0 || intersection.Height <= 0)
+                    continue;
+
+                int cropX = Math.Max(0, (int)Math.Round(intersection.Left - windowBounds.Left));
+                int cropY = Math.Max(0, (int)Math.Round(intersection.Top - windowBounds.Top));
+                int cropW = Math.Min((int)Math.Round(intersection.Width), backgroundBitmap.PixelWidth - cropX);
+                int cropH = Math.Min((int)Math.Round(intersection.Height), backgroundBitmap.PixelHeight - cropY);
+
+                if (cropW <= 0 || cropH <= 0)
+                    continue;
+
+                CroppedBitmap croppedBitmap = new(backgroundBitmap, new Int32Rect(cropX, cropY, cropW, cropH));
+                croppedBitmap.Freeze();
+
+                Rect destinationRect = new(
+                    intersection.Left - absoluteCaptureRect.Left,
+                    intersection.Top - absoluteCaptureRect.Top,
+                    cropW,
+                    cropH);
+
+                drawingContext.DrawImage(croppedBitmap, destinationRect);
+                drawnSegments++;
+            }
+        }
+
+        if (drawnSegments == 0)
+            return null;
+
+        RenderTargetBitmap renderedBitmap = new(targetWidth, targetHeight, 96, 96, PixelFormats.Pbgra32);
+        renderedBitmap.Render(drawingVisual);
+        renderedBitmap.Freeze();
+        return renderedBitmap;
+    }
+
+    private void EnterAdjustAfterMode()
+    {
+        isAwaitingAdjustAfterCommit = true;
+        selectionInteractionMode = SelectionInteractionMode.None;
+        selectBorder.Background = Brushes.Transparent;
+        AcceptSelectionButton.Visibility = Visibility.Visible;
+        TopButtonsStackPanel.Visibility = Visibility.Visible;
+        UpdateSelectionHandles();
+        UpdateAdjustAfterCursor(Mouse.GetPosition(this));
+    }
+
+    private Rect GetHistoryPositionRect(FullscreenCaptureResult selection)
+    {
+        if (selection.SelectionStyle is FsgSelectionStyle.Region or FsgSelectionStyle.AdjustAfter)
+        {
+            GetDpiAdjustedRegionOfSelectBorder(out _, out double posLeft, out double posTop);
+            return new Rect(posLeft, posTop, selectBorder.Width, selectBorder.Height);
+        }
+
+        DpiScale dpi = VisualTreeHelper.GetDpi(this);
+        return new Rect(
+            selection.CaptureRegion.X / dpi.DpiScaleX,
+            selection.CaptureRegion.Y / dpi.DpiScaleY,
+            selection.CaptureRegion.Width / dpi.DpiScaleX,
+            selection.CaptureRegion.Height / dpi.DpiScaleY);
+    }
+
+    private BitmapSource? GetBitmapSourceForGrabFrame(FullscreenCaptureResult selection)
+    {
+        if (selection.CapturedImage is not null)
+            return selection.CapturedImage;
+
+        if (selection.SelectionStyle is FsgSelectionStyle.Region or FsgSelectionStyle.AdjustAfter
+            && BackgroundImage.Source is BitmapSource backgroundBitmap
+            && RegionClickCanvas.Children.Contains(selectBorder))
+        {
+            PresentationSource? presentationSource = PresentationSource.FromVisual(this);
+            Matrix transformToDevice = presentationSource?.CompositionTarget?.TransformToDevice ?? Matrix.Identity;
+            Rect selectionRect = GetCurrentSelectionRect();
+
+            if (TryGetBitmapCropRectForSelection(
+                selectionRect,
+                transformToDevice,
+                BackgroundImage.RenderTransform,
+                backgroundBitmap.PixelWidth,
+                backgroundBitmap.PixelHeight,
+                out Int32Rect cropRect))
+            {
+                CroppedBitmap croppedBitmap = new(backgroundBitmap, cropRect);
+                croppedBitmap.Freeze();
+                return croppedBitmap;
+            }
+        }
+
+        using Bitmap capturedBitmap = ImageMethods.GetRegionOfScreenAsBitmap(selection.CaptureRegion.AsRectangle(), cacheResult: false);
+        return ImageMethods.BitmapToImageSource(capturedBitmap);
+    }
+
+    private Task PlaceGrabFrameInSelectionRectAsync(FullscreenCaptureResult selection)
+    {
+        BitmapSource? frozenImage = GetBitmapSourceForGrabFrame(selection);
+        GrabFrame grabFrame = frozenImage is not null ? new GrabFrame(frozenImage) : new GrabFrame();
+
+        DpiScale dpi = VisualTreeHelper.GetDpi(this);
+        Rect selectionRect = new(
+            selection.CaptureRegion.X / dpi.DpiScaleX,
+            selection.CaptureRegion.Y / dpi.DpiScaleY,
+            selection.CaptureRegion.Width / dpi.DpiScaleX,
+            selection.CaptureRegion.Height / dpi.DpiScaleY);
+
+        grabFrame.Left = selectionRect.Left - (2 / dpi.PixelsPerDip);
+        grabFrame.Top = selectionRect.Top - (48 / dpi.PixelsPerDip);
+
+        if (destinationTextBox is not null)
+            grabFrame.DestinationTextBox = destinationTextBox;
+
+        grabFrame.TableToggleButton.IsChecked = TableToggleButton.IsChecked;
+        if (selectionRect.Width > 20 && selectionRect.Height > 20)
+        {
+            grabFrame.Width = selectionRect.Width + 4;
+            grabFrame.Height = selectionRect.Height + 74;
+        }
+
+        grabFrame.Show();
+        grabFrame.Activate();
+
+        DisposeBitmapSource(BackgroundImage);
+        WindowUtilities.CloseAllFullscreenGrabs();
+        return Task.CompletedTask;
+    }
+
+    private static bool IsTemplateAction(ButtonInfo action) => action.ClickEvent == "ApplyTemplate_Click";
+
+    private async Task CommitSelectionAsync(FullscreenCaptureResult selection, bool isSmallClick)
+    {
+        clickedWindowCandidate = null;
+
+        if (NewGrabFrameMenuItem.IsChecked is true)
+        {
+            await PlaceGrabFrameInSelectionRectAsync(selection);
+            return;
+        }
+
+        if (LanguagesComboBox.SelectedItem is not ILanguage selectedOcrLang)
+            selectedOcrLang = LanguageUtilities.GetOCRLanguage();
+
+        bool isSingleLine = SingleLineMenuItem is not null && SingleLineMenuItem.IsChecked;
+        bool isTable = TableMenuItem is not null && TableMenuItem.IsChecked;
+        TextFromOCR = string.Empty;
+
+        if (isSmallClick && selection.SelectionStyle == FsgSelectionStyle.Region)
+        {
+            BackgroundBrush.Opacity = 0;
+            PresentationSource? presentationSource = PresentationSource.FromVisual(this);
+            Matrix transformToDevice = presentationSource?.CompositionTarget?.TransformToDevice ?? Matrix.Identity;
+            Rect selectionRect = GetCurrentSelectionRect();
+            Point clickedPointForOcr = new(
+                Math.Round(selectionRect.Left * transformToDevice.M11),
+                Math.Round(selectionRect.Top * transformToDevice.M22));
+
+            TextFromOCR = await OcrUtilities.GetClickedWordAsync(this, clickedPointForOcr, selectedOcrLang);
+        }
+        else if (selection.CapturedImage is not null)
+        {
+            TextFromOCR = isTable
+                ? await OcrUtilities.GetTextFromBitmapSourceAsTableAsync(selection.CapturedImage, selectedOcrLang)
+                : await OcrUtilities.GetTextFromBitmapSourceAsync(selection.CapturedImage, selectedOcrLang);
+        }
+        else if (isTable)
+        {
+            using Bitmap selectionBitmap = ImageMethods.GetRegionOfScreenAsBitmap(selection.CaptureRegion.AsRectangle());
+            TextFromOCR = await OcrUtilities.GetTextFromBitmapAsTableAsync(selectionBitmap, selectedOcrLang);
+        }
+        else
+        {
+            TextFromOCR = await OcrUtilities.GetTextFromAbsoluteRectAsync(selection.CaptureRegion, selectedOcrLang);
+        }
+
+        if (DefaultSettings.UseHistory && !isSmallClick)
+        {
+            Bitmap? historyBitmap = selection.CapturedImage is not null
+                ? ImageMethods.BitmapSourceToBitmap(selection.CapturedImage)
+                : Singleton<HistoryService>.Instance.CachedBitmap is Bitmap cachedBitmap
+                    ? new Bitmap(cachedBitmap)
+                    : null;
+
+            historyInfo = new HistoryInfo
+            {
+                ID = Guid.NewGuid().ToString(),
+                DpiScaleFactor = GetCurrentDeviceScale(),
+                LanguageTag = LanguageUtilities.GetLanguageTag(selectedOcrLang),
+                LanguageKind = LanguageUtilities.GetLanguageKind(selectedOcrLang),
+                CaptureDateTime = DateTimeOffset.Now,
+                PositionRect = GetHistoryPositionRect(selection),
+                IsTable = TableToggleButton.IsChecked!.Value,
+                TextContent = TextFromOCR,
+                ImageContent = historyBitmap,
+                SourceMode = TextGrabMode.Fullscreen,
+                SelectionStyle = selection.SelectionStyle,
+            };
+        }
+
+        if (string.IsNullOrWhiteSpace(TextFromOCR))
+        {
+            BackgroundBrush.Opacity = DefaultSettings.FsgShadeOverlay ? .2 : 0.0;
+            TopButtonsStackPanel.Visibility = Visibility.Visible;
+
+            if (selection.SelectionStyle == FsgSelectionStyle.AdjustAfter)
+                EnterAdjustAfterMode();
+            else
+                ResetSelectionVisualState();
+
+            return;
+        }
+
+        if (NextStepDropDownButton.Flyout is ContextMenu contextMenu)
+        {
+            bool shouldInsert = false;
+            bool showedFreeformTemplateMessage = false;
+
+            foreach (MenuItem menuItem in GetActionablePostGrabMenuItems(contextMenu))
+            {
+                if (!menuItem.IsChecked || menuItem.Tag is not ButtonInfo action)
+                    continue;
+
+                if (action.ClickEvent == "Insert_Click")
+                {
+                    shouldInsert = true;
+                    continue;
+                }
+
+                if (!selection.SupportsTemplateActions && IsTemplateAction(action))
+                {
+                    if (!showedFreeformTemplateMessage)
+                    {
+                        MessageBox.Show(
+                            "Grab Templates are currently available only for rectangular selections. Freeform captures will keep their OCR text without applying templates.",
+                            "Text Grab",
+                            MessageBoxButton.OK,
+                            MessageBoxImage.Information);
+                        showedFreeformTemplateMessage = true;
+                    }
+
+                    continue;
+                }
+
+                PostGrabContext grabContext = new(
+                    Text: TextFromOCR ?? string.Empty,
+                    CaptureRegion: selection.CaptureRegion,
+                    DpiScale: GetCurrentDeviceScale(),
+                    CapturedImage: selection.CapturedImage,
+                    Language: selectedOcrLang,
+                    SelectionStyle: selection.SelectionStyle);
+
+                TextFromOCR = await PostGrabActionManager.ExecutePostGrabAction(action, grabContext);
+            }
+
+            if (shouldInsert && !DefaultSettings.TryInsert)
+            {
+                string textToInsert = TextFromOCR;
+                _ = Task.Run(async () =>
+                {
+                    await Task.Delay(100);
+                    await WindowUtilities.TryInsertString(textToInsert);
+                });
+            }
+        }
+
+        if (SendToEditTextToggleButton.IsChecked is true
+            && destinationTextBox is null)
+        {
+            bool isWebSearch = false;
+            if (NextStepDropDownButton.Flyout is ContextMenu postCaptureMenu)
+            {
+                foreach (MenuItem menuItem in GetActionablePostGrabMenuItems(postCaptureMenu))
+                {
+                    if (menuItem.IsChecked
+                        && menuItem.Tag is ButtonInfo action
+                        && action.ClickEvent == "WebSearch_Click")
+                    {
+                        isWebSearch = true;
+                        break;
+                    }
+                }
+            }
+
+            if (!isWebSearch)
+            {
+                EditTextWindow etw = WindowUtilities.OpenOrActivateWindow<EditTextWindow>();
+                destinationTextBox = etw.PassedTextControl;
+            }
+        }
+
+        OutputUtilities.HandleTextFromOcr(
+            TextFromOCR,
+            isSingleLine,
+            isTable,
+            destinationTextBox);
+        WindowUtilities.CloseAllFullscreenGrabs();
+    }
+
+    private async void AcceptSelectionButton_Click(object sender, RoutedEventArgs e)
+    {
+        if (!isAwaitingAdjustAfterCommit)
+            return;
+
+        isAwaitingAdjustAfterCommit = false;
+        ClearSelectionHandles();
+        AcceptSelectionButton.Visibility = Visibility.Collapsed;
+
+        await CommitSelectionAsync(CreateRectangleSelectionResult(FsgSelectionStyle.AdjustAfter), false);
+    }
+
+    private void HandleRegionCanvasMouseDown(MouseButtonEventArgs e)
+    {
+        switch (CurrentSelectionStyle)
+        {
+            case FsgSelectionStyle.Window:
+                clickedWindowCandidate = GetWindowSelectionCandidateAtCurrentMousePosition() ?? hoveredWindowCandidate;
+                ApplyWindowSelectionHighlight(clickedWindowCandidate);
+
+                if (clickedWindowCandidate is not null)
+                    RegionClickCanvas.CaptureMouse();
+                break;
+            case FsgSelectionStyle.Freeform:
+                BeginFreeformSelection(e);
+                break;
+            case FsgSelectionStyle.AdjustAfter:
+                if (!TryBeginAdjustAfterInteraction(e))
+                    BeginRectangleSelection(e);
+                break;
+            case FsgSelectionStyle.Region:
+            default:
+                BeginRectangleSelection(e);
+                break;
+        }
+    }
+
+    private void HandleRegionCanvasMouseMove(MouseEventArgs e)
+    {
+        Point movingPoint = e.GetPosition(this);
+
+        switch (selectionInteractionMode)
+        {
+            case SelectionInteractionMode.CreatingRectangle:
+                UpdateRectangleSelection(movingPoint);
+                break;
+            case SelectionInteractionMode.CreatingFreeform:
+                UpdateFreeformSelection(movingPoint);
+                break;
+            case SelectionInteractionMode.None:
+                if (CurrentSelectionStyle == FsgSelectionStyle.AdjustAfter)
+                    UpdateAdjustAfterCursor(movingPoint);
+                break;
+            default:
+                UpdateAdjustedSelection(movingPoint);
+                break;
+        }
+    }
+
+    private async Task HandleRegionCanvasMouseUpAsync(MouseButtonEventArgs e)
+    {
+        switch (selectionInteractionMode)
+        {
+            case SelectionInteractionMode.CreatingRectangle:
+                await FinalizeRectangleSelectionAsync();
+                break;
+            case SelectionInteractionMode.CreatingFreeform:
+                await FinalizeFreeformSelectionAsync();
+                break;
+            case SelectionInteractionMode.MovingSelection:
+            case SelectionInteractionMode.ResizeLeft:
+            case SelectionInteractionMode.ResizeTop:
+            case SelectionInteractionMode.ResizeRight:
+            case SelectionInteractionMode.ResizeBottom:
+            case SelectionInteractionMode.ResizeTopLeft:
+            case SelectionInteractionMode.ResizeTopRight:
+            case SelectionInteractionMode.ResizeBottomLeft:
+            case SelectionInteractionMode.ResizeBottomRight:
+                EndSelectionInteraction();
+                UpdateSelectionHandles();
+                UpdateAdjustAfterCursor(e.GetPosition(this));
+                break;
+            default:
+                if (CurrentSelectionStyle == FsgSelectionStyle.Window)
+                {
+                    WindowSelectionCandidate? pressedWindowCandidate = clickedWindowCandidate;
+                    WindowSelectionCandidate? releasedWindowCandidate = GetWindowSelectionCandidateAtCurrentMousePosition() ?? hoveredWindowCandidate;
+
+                    if (RegionClickCanvas.IsMouseCaptured)
+                        RegionClickCanvas.ReleaseMouseCapture();
+
+                    ApplyWindowSelectionHighlight(releasedWindowCandidate);
+
+                    if (ShouldCommitWindowSelection(pressedWindowCandidate, releasedWindowCandidate)
+                        && pressedWindowCandidate is not null)
+                    {
+                        await CommitSelectionAsync(
+                            CreateWindowSelectionResult(pressedWindowCandidate),
+                            false);
+                    }
+                }
+
+                clickedWindowCandidate = null;
+                break;
+        }
+    }
+}
diff --git a/Text-Grab/Views/FullscreenGrab.xaml b/Text-Grab/Views/FullscreenGrab.xaml
index 5011adc1..35902a56 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml
+++ b/Text-Grab/Views/FullscreenGrab.xaml
@@ -21,22 +21,12 @@
     mc:Ignorable="d">
 
     <Window.Resources>
-        <Style x:Key="SymbolTextStyle" TargetType="TextBlock">
-            <Setter Property="HorizontalAlignment" Value="Center" />
-            <Setter Property="VerticalAlignment" Value="Center" />
-            <Setter Property="FontFamily" Value="Segoe MDL2 Assets" />
-            <Setter Property="FontSize" Value="16" />
-            <Setter Property="Margin" Value="4" />
-        </Style>
-        <Style TargetType="ToggleButton">
-            <Setter Property="Margin" Value="2,0" />
-            <Setter Property="VerticalAlignment" Value="Center" />
-            <Setter Property="HorizontalAlignment" Value="Center" />
-            <Setter Property="Width" Value="30" />
-            <Setter Property="Height" Value="30" />
-        </Style>
-
-
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <ResourceDictionary Source="/Styles/SelectionStyleComboBoxItemStyle.xaml" />
+                <ResourceDictionary Source="/Styles/SelectionStyleComboBoxStyle.xaml" />
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
     </Window.Resources>
 
     <Grid d:Background="NavajoWhite">
@@ -85,6 +75,37 @@
                         Header="Freeze"
                         IsCheckable="True"
                         IsChecked="True" />
+                    <MenuItem Header="Selection Style">
+                        <MenuItem
+                            x:Name="RegionSelectionMenuItem"
+                            Click="SelectionStyleMenuItem_Click"
+                            Header="Rectangle 1 - Drag a box"
+                            InputGestureText="R"
+                            IsCheckable="True"
+                            IsChecked="True"
+                            Tag="Region" />
+                        <MenuItem
+                            x:Name="WindowSelectionMenuItem"
+                            Click="SelectionStyleMenuItem_Click"
+                            Header="Window - Hover and click"
+                            InputGestureText="W"
+                            IsCheckable="True"
+                            Tag="Window" />
+                        <MenuItem
+                            x:Name="FreeformSelectionMenuItem"
+                            Click="SelectionStyleMenuItem_Click"
+                            Header="Freeform - Draw any shape"
+                            InputGestureText="D"
+                            IsCheckable="True"
+                            Tag="Freeform" />
+                        <MenuItem
+                            x:Name="AdjustAfterSelectionMenuItem"
+                            Click="SelectionStyleMenuItem_Click"
+                            Header="Rectangle 2 - Drag, then adjust"
+                            InputGestureText="A"
+                            IsCheckable="True"
+                            Tag="AdjustAfter" />
+                    </MenuItem>
                     <Separator />
                     <MenuItem
                         Name="NewGrabFrameMenuItem"
@@ -112,6 +133,8 @@
                 </ContextMenu>
             </Canvas.ContextMenu>
         </Canvas>
+        <Canvas x:Name="SelectionOutlineHost" IsHitTestVisible="False" />
+        <Canvas x:Name="TemplateOverlayHost" IsHitTestVisible="False" />
         <Border
             x:Name="TopButtonsStackPanel"
             Margin="12"
@@ -137,6 +160,28 @@
                 HorizontalAlignment="Center"
                 VerticalAlignment="Top"
                 Orientation="Horizontal">
+                <ComboBox
+                    x:Name="SelectionStyleComboBox"
+                    Width="34"
+                    Height="34"
+                    Margin="0,0,4,0"
+                    ItemContainerStyle="{StaticResource SelectionStyleComboBoxItemStyle}"
+                    SelectionChanged="SelectionStyleComboBox_SelectionChanged"
+                    Style="{StaticResource SelectionStyleComboBoxStyle}"
+                    ToolTip="Choose how to define the capture area.">
+                    <ComboBoxItem Tag="Region" ToolTip="Region select (R)">
+                        <wpfui:SymbolIcon FontSize="22" Symbol="RectangleLandscape24" />
+                    </ComboBoxItem>
+                    <ComboBoxItem Tag="Window" ToolTip="Window select (W)">
+                        <wpfui:SymbolIcon FontSize="22" Symbol="WindowMultiple20" />
+                    </ComboBoxItem>
+                    <ComboBoxItem Tag="Freeform" ToolTip="Draw freeform shape (D)">
+                        <wpfui:SymbolIcon FontSize="22" Symbol="DrawShape24" />
+                    </ComboBoxItem>
+                    <ComboBoxItem Tag="AdjustAfter" ToolTip="Adjust after (A)">
+                        <wpfui:SymbolIcon FontSize="22" Symbol="SelectObject24" />
+                    </ComboBoxItem>
+                </ComboBox>
                 <ComboBox
                     x:Name="LanguagesComboBox"
                     Height="34"
@@ -289,6 +334,15 @@
                         </ContextMenu>
                     </wpfui:DropDownButton.Flyout>
                 </wpfui:DropDownButton>
+                <Button
+                    x:Name="AcceptSelectionButton"
+                    Width="44"
+                    Height="34"
+                    Margin="2,0"
+                    Click="AcceptSelectionButton_Click"
+                    Content="OK"
+                    ToolTip="(Enter) Accept selection"
+                    Visibility="Collapsed" />
                 <ToggleButton
                     x:Name="SendToEditTextToggleButton"
                     Width="34"
diff --git a/Text-Grab/Views/FullscreenGrab.xaml.cs b/Text-Grab/Views/FullscreenGrab.xaml.cs
index 7027068b..78ffa652 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml.cs
+++ b/Text-Grab/Views/FullscreenGrab.xaml.cs
@@ -1,7 +1,7 @@
 using Dapplo.Windows.User32;
 using System;
 using System.Collections.Generic;
-using System.Drawing;
+using System.Linq;
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
@@ -11,7 +11,6 @@
 using System.Windows.Media.Imaging;
 using System.Windows.Threading;
 using Text_Grab.Controls;
-using Text_Grab.Extensions;
 using Text_Grab.Interfaces;
 using Text_Grab.Models;
 using Text_Grab.Properties;
@@ -44,6 +43,7 @@ public partial class FullscreenGrab : Window
     private HistoryInfo? historyInfo;
     private readonly bool usingTesseract;
     private static readonly Settings DefaultSettings = AppUtilities.TextGrabSettings;
+    private readonly Canvas templateOverlayCanvas = new() { ClipToBounds = true, IsHitTestVisible = false };
 
     private const double MaxZoomScale = 16.0;
     private const double EdgePanThresholdPercent = 0.10;
@@ -61,6 +61,7 @@ public FullscreenGrab()
         InitializeComponent();
         App.SetTheme();
         usingTesseract = DefaultSettings.UseTesseract && TesseractHelper.CanLocateTesseractExe();
+        InitializeSelectionStyles();
 
         edgePanTimer = new DispatcherTimer
         {
@@ -88,6 +89,7 @@ public TextBox? DestinationTextBox
 
     public bool IsFreeze { get; set; } = false;
     public string? TextFromOCR { get; set; }
+    public string? PreselectedTemplateId { get; set; }
     private DisplayInfo? CurrentScreen { get; set; }
 
     #endregion Properties
@@ -191,6 +193,18 @@ internal void KeyPressed(Key key, bool? isActive = null)
                 else
                     SelectSingleToggleButton();
                 break;
+            case Key.R:
+                ApplySelectionStyle(FsgSelectionStyle.Region);
+                break;
+            case Key.W:
+                ApplySelectionStyle(FsgSelectionStyle.Window);
+                break;
+            case Key.D:
+                ApplySelectionStyle(FsgSelectionStyle.Freeform);
+                break;
+            case Key.A:
+                ApplySelectionStyle(FsgSelectionStyle.AdjustAfter);
+                break;
             case Key.D1:
             case Key.D2:
             case Key.D3:
@@ -203,19 +217,7 @@ internal void KeyPressed(Key key, bool? isActive = null)
                 int numberPressed = (int)key - 34; // D1 casts to 35, D2 to 36, etc.
 
                 if (KeyboardExtensions.IsCtrlDown())
-                {
-                    if (NextStepDropDownButton.Flyout is not ContextMenu flyoutMenu
-                        || !flyoutMenu.HasItems
-                        || numberPressed - 1 >= flyoutMenu.Items.Count
-                        || flyoutMenu.Items[numberPressed - 1] is not MenuItem selectedItem)
-                    {
-                        return;
-                    }
-
-                    selectedItem.IsChecked = !selectedItem.IsChecked;
-                    CheckIfAnyPostActionsSelected();
                     return;
-                }
 
                 int numberOfLanguages = LanguagesComboBox.Items.Count;
                 if (numberPressed <= numberOfLanguages
@@ -229,14 +231,75 @@ internal void KeyPressed(Key key, bool? isActive = null)
         }
     }
 
+    internal static string GetPostGrabActionKey(ButtonInfo action)
+    {
+        if (!string.IsNullOrWhiteSpace(action.TemplateId))
+            return $"template:{action.TemplateId}";
+
+        if (!string.IsNullOrWhiteSpace(action.ClickEvent))
+            return $"click:{action.ClickEvent}";
+
+        return $"text:{action.ButtonText}";
+    }
+
+    internal static List<MenuItem> GetActionablePostGrabMenuItems(ContextMenu contextMenu)
+    {
+        return [.. contextMenu.Items
+            .OfType<MenuItem>()
+            .Where(static item => item.Tag is ButtonInfo)];
+    }
+
+    internal static Dictionary<string, bool> BuildPostGrabActionSnapshot(
+        IEnumerable<MenuItem> actionableItems,
+        string? changedActionKey = null,
+        bool? changedIsChecked = null)
+    {
+        List<(MenuItem MenuItem, ButtonInfo Action, string ActionKey)> postGrabItems = [];
+
+        foreach (MenuItem menuItem in actionableItems)
+        {
+            if (menuItem.Tag is not ButtonInfo action)
+                continue;
+
+            postGrabItems.Add((menuItem, action, GetPostGrabActionKey(action)));
+        }
+
+        Dictionary<string, bool> actionStates = [];
+        foreach ((MenuItem menuItem, _, string actionKey) in postGrabItems)
+        {
+            bool isChecked = changedActionKey == actionKey && changedIsChecked.HasValue
+                ? changedIsChecked.Value
+                : menuItem.IsChecked;
+            actionStates[actionKey] = isChecked;
+        }
+
+        List<string> checkedTemplateKeys = [.. postGrabItems
+            .Where(item => !string.IsNullOrWhiteSpace(item.Action.TemplateId) && actionStates[item.ActionKey])
+            .Select(item => item.ActionKey)];
+
+        if (checkedTemplateKeys.Count > 1)
+        {
+            string templateToKeep = !string.IsNullOrWhiteSpace(changedActionKey)
+                && changedIsChecked == true
+                && checkedTemplateKeys.Contains(changedActionKey)
+                ? changedActionKey
+                : checkedTemplateKeys[0];
+
+            foreach (string templateKey in checkedTemplateKeys.Where(key => key != templateToKeep))
+                actionStates[templateKey] = false;
+        }
+
+        return actionStates;
+    }
+
     private void CheckIfAnyPostActionsSelected()
     {
         if (NextStepDropDownButton.Flyout is not ContextMenu flyoutMenu || !flyoutMenu.HasItems)
             return;
 
-        foreach (object anyItem in flyoutMenu.Items)
+        foreach (MenuItem item in GetActionablePostGrabMenuItems(flyoutMenu))
         {
-            if (anyItem is MenuItem item && item.IsChecked is true)
+            if (item.IsChecked)
             {
                 if (FindResource("DarkTeal") is SolidColorBrush tealButtonStyle)
                     NextStepDropDownButton.Background = tealButtonStyle;
@@ -258,6 +321,138 @@ private static bool CheckIfCheckingOrUnchecking(object? sender)
         return isActive;
     }
 
+    private void RefreshPostGrabActionVisuals()
+    {
+        CheckIfAnyPostActionsSelected();
+
+        if (CurrentSelectionStyle == FsgSelectionStyle.Freeform)
+        {
+            TemplateOverlayHost.Children.Clear();
+            templateOverlayCanvas.Children.Clear();
+            return;
+        }
+
+        if (RegionClickCanvas.Children.Contains(selectBorder)
+            && selectBorder.Width > 2
+            && selectBorder.Height > 2)
+        {
+            double selLeft = Canvas.GetLeft(selectBorder);
+            double selTop = Canvas.GetTop(selectBorder);
+
+            if (!double.IsNaN(selLeft) && !double.IsNaN(selTop))
+            {
+                UpdateTemplateRegionOverlays(selLeft, selTop, selectBorder.Width, selectBorder.Height);
+                return;
+            }
+        }
+
+        TemplateOverlayHost.Children.Clear();
+        templateOverlayCanvas.Children.Clear();
+    }
+
+    private void SynchronizePostGrabActionShortcut(int actionIndex)
+    {
+        if (NextStepDropDownButton.Flyout is not ContextMenu contextMenu || !contextMenu.HasItems)
+            return;
+
+        List<MenuItem> actionableItems = GetActionablePostGrabMenuItems(contextMenu);
+        if (actionIndex < 0 || actionIndex >= actionableItems.Count)
+            return;
+
+        MenuItem selectedItem = actionableItems[actionIndex];
+        SynchronizePostGrabActionSelection(selectedItem, !selectedItem.IsChecked);
+    }
+
+    private void SynchronizePostGrabActionSelection(MenuItem menuItem, bool isChecked)
+    {
+        if (menuItem.Tag is not ButtonInfo action
+            || menuItem.Parent is not ContextMenu contextMenu)
+        {
+            RefreshPostGrabActionVisuals();
+            return;
+        }
+
+        Dictionary<string, bool> actionStates = BuildPostGrabActionSnapshot(
+            GetActionablePostGrabMenuItems(contextMenu),
+            GetPostGrabActionKey(action),
+            isChecked);
+
+        ApplyPostGrabActionSnapshot(
+            actionStates,
+            persistLastUsed: true,
+            forcePersistActionKey: GetPostGrabActionKey(action));
+        WindowUtilities.SyncFullscreenPostGrabActionStates(actionStates, this);
+    }
+
+    internal static bool ShouldPersistLastUsedState(ButtonInfo action, bool previousChecked, bool isChecked, string? forcePersistActionKey = null)
+    {
+        if (action.DefaultCheckState != DefaultCheckState.LastUsed)
+            return false;
+
+        return previousChecked != isChecked || GetPostGrabActionKey(action) == forcePersistActionKey;
+    }
+
+    internal void ApplyPostGrabActionSnapshot(
+        IReadOnlyDictionary<string, bool> actionStates,
+        bool persistLastUsed = false,
+        string? forcePersistActionKey = null)
+    {
+        if (NextStepDropDownButton.Flyout is not ContextMenu contextMenu || !contextMenu.HasItems)
+            return;
+
+        foreach (MenuItem menuItem in GetActionablePostGrabMenuItems(contextMenu))
+        {
+            if (menuItem.Tag is not ButtonInfo action)
+                continue;
+
+            bool previousChecked = menuItem.IsChecked;
+            bool isChecked = actionStates.TryGetValue(GetPostGrabActionKey(action), out bool syncedState) && syncedState;
+            menuItem.IsChecked = isChecked;
+
+            if (persistLastUsed
+                && ShouldPersistLastUsedState(action, previousChecked, isChecked, forcePersistActionKey))
+            {
+                PostGrabActionManager.SaveCheckState(action, isChecked);
+            }
+        }
+
+        RefreshPostGrabActionVisuals();
+    }
+
+    private void AddPostGrabActionMenuItem(ContextMenu contextMenu, ButtonInfo action, bool isChecked, bool stayOpen, int shortcutIndex)
+    {
+        MenuItem menuItem = new()
+        {
+            Header = action.ButtonText,
+            IsCheckable = true,
+            Tag = action,
+            IsChecked = isChecked,
+            StaysOpenOnClick = stayOpen,
+            InputGestureText = shortcutIndex <= 9 ? $"Ctrl+{shortcutIndex}" : string.Empty
+        };
+
+        menuItem.Click += PostActionMenuItem_Click;
+        contextMenu.Items.Add(menuItem);
+    }
+
+    private List<ButtonInfo> GetEnabledPostGrabActionsForMenu()
+    {
+        List<ButtonInfo> enabledActions = PostGrabActionManager.GetEnabledPostGrabActions();
+
+        if (string.IsNullOrWhiteSpace(PreselectedTemplateId)
+            || enabledActions.Any(action => action.TemplateId == PreselectedTemplateId))
+        {
+            return enabledActions;
+        }
+
+        GrabTemplate? template = GrabTemplateManager.GetTemplateById(PreselectedTemplateId);
+        if (template is null)
+            return enabledActions;
+
+        enabledActions.Add(GrabTemplateManager.CreateButtonInfoForTemplate(template));
+        return enabledActions;
+    }
+
     private void LoadDynamicPostGrabActions()
     {
         if (NextStepDropDownButton.Flyout is not ContextMenu contextMenu)
@@ -266,44 +461,42 @@ private void LoadDynamicPostGrabActions()
         // Clear existing items
         contextMenu.Items.Clear();
 
-        // Get enabled post-grab actions from settings
-        List<ButtonInfo> enabledActions = PostGrabActionManager.GetEnabledPostGrabActions();
+        List<ButtonInfo> enabledActions = GetEnabledPostGrabActionsForMenu();
 
-        // Get the PostGrabStayOpen setting
         bool stayOpen = DefaultSettings.PostGrabStayOpen;
 
-        // Remove any existing keyboard handler to avoid duplicates
         contextMenu.PreviewKeyDown -= FullscreenGrab_KeyDown;
-        
-        // Add keyboard handling once for the entire context menu
         contextMenu.PreviewKeyDown += FullscreenGrab_KeyDown;
 
+        List<ButtonInfo> regularActions = [.. enabledActions.Where(a => string.IsNullOrEmpty(a.TemplateId))];
+        List<ButtonInfo> templateActions = [.. enabledActions.Where(a => !string.IsNullOrEmpty(a.TemplateId))];
+        bool templatePreselected = !string.IsNullOrEmpty(PreselectedTemplateId);
+
         int index = 1;
-        foreach (ButtonInfo action in enabledActions)
+        foreach (ButtonInfo action in regularActions)
         {
-            MenuItem menuItem = new()
-            {
-                Header = action.ButtonText,
-                IsCheckable = true,
-                Tag = action,
-                IsChecked = PostGrabActionManager.GetCheckState(action),
-                StaysOpenOnClick = stayOpen,
-                InputGestureText = $"Ctrl+{index}"
-            };
+            AddPostGrabActionMenuItem(contextMenu, action, PostGrabActionManager.GetCheckState(action), stayOpen, index);
+            index++;
+        }
+
+        if (regularActions.Count > 0 && templateActions.Count > 0)
+            contextMenu.Items.Add(new Separator());
 
-            // Wire up click handler
-            menuItem.Click += PostActionMenuItem_Click;
+        foreach (ButtonInfo action in templateActions)
+        {
+            bool isChecked = templatePreselected
+                ? action.TemplateId == PreselectedTemplateId
+                : PostGrabActionManager.GetCheckState(action);
 
-            contextMenu.Items.Add(menuItem);
+            AddPostGrabActionMenuItem(contextMenu, action, isChecked, stayOpen, index);
             index++;
         }
 
         contextMenu.Items.Add(new Separator());
 
-        // Add "Edit this list..." menu item
         MenuItem editPostGrabMenuItem = new()
         {
-            Header = "Edit this list...",
+            Header = "✨ Customize Actions \u0026 Templates...",
             Tag = EditPostGrabActionsTag
         };
         editPostGrabMenuItem.Click += EditPostGrabActions_Click;
@@ -318,8 +511,14 @@ private void LoadDynamicPostGrabActions()
         hidePostGrabMenuItem.Click += HidePostGrabActions_Click;
         contextMenu.Items.Add(hidePostGrabMenuItem);
 
-        // Update the dropdown button appearance
-        CheckIfAnyPostActionsSelected();
+        IReadOnlyDictionary<string, bool>? synchronizedActionStates = WindowUtilities.GetFullscreenPostGrabActionStates();
+        if (synchronizedActionStates is not null)
+        {
+            ApplyPostGrabActionSnapshot(synchronizedActionStates);
+            return;
+        }
+
+        RefreshPostGrabActionVisuals();
     }
 
     private void CancelMenuItem_Click(object sender, RoutedEventArgs e)
@@ -361,6 +560,23 @@ private async void FreezeUnfreeze(bool Activate)
 
     private void FullscreenGrab_KeyDown(object sender, KeyEventArgs e)
     {
+        if (e.Key == Key.Enter && isAwaitingAdjustAfterCommit)
+        {
+            AcceptSelectionButton_Click(this, new RoutedEventArgs());
+            e.Handled = true;
+            return;
+        }
+
+        int keyValue = (int)e.Key;
+        if (KeyboardExtensions.IsCtrlDown()
+            && keyValue >= (int)Key.D1
+            && keyValue <= (int)Key.D9)
+        {
+            SynchronizePostGrabActionShortcut(keyValue - (int)Key.D1);
+            e.Handled = true;
+            return;
+        }
+
         WindowUtilities.FullscreenKeyDown(e.Key);
     }
 
@@ -378,6 +594,85 @@ private void FullscreenGrab_KeyUp(object sender, KeyEventArgs e)
         }
     }
 
+    private GrabTemplate? GetActiveTemplate()
+    {
+        if (NextStepDropDownButton.Flyout is not ContextMenu contextMenu)
+            return null;
+
+        foreach (MenuItem menuItem in GetActionablePostGrabMenuItems(contextMenu))
+        {
+            if (menuItem.IsChecked
+                && menuItem.Tag is ButtonInfo action
+                && action.ClickEvent == "ApplyTemplate_Click"
+                && !string.IsNullOrEmpty(action.TemplateId))
+            {
+                return GrabTemplateManager.GetTemplateById(action.TemplateId);
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Draws scaled template region overlays inside the current selection border.
+    /// Each region's stored ratio coordinates are applied directly to the current
+    /// selection dimensions (stretch-to-fill), so both axes scale independently.
+    /// </summary>
+    private void UpdateTemplateRegionOverlays(double selLeft, double selTop, double selWidth, double selHeight)
+    {
+        TemplateOverlayHost.Children.Clear();
+        templateOverlayCanvas.Children.Clear();
+
+        if (CurrentSelectionStyle == FsgSelectionStyle.Freeform)
+            return;
+
+        GrabTemplate? template = GetActiveTemplate();
+        if (template is null || template.Regions.Count == 0)
+            return;
+
+        // If the output template references no regions (pattern-only), skip overlays
+        HashSet<int> referencedRegions = [.. template.GetReferencedRegionNumbers()];
+        if (referencedRegions.Count == 0 && template.PatternMatches.Count > 0)
+            return;
+
+        if (selWidth < 4 || selHeight < 4)
+            return;
+
+        templateOverlayCanvas.Width = selWidth;
+        templateOverlayCanvas.Height = selHeight;
+        Canvas.SetLeft(templateOverlayCanvas, selLeft);
+        Canvas.SetTop(templateOverlayCanvas, selTop);
+
+        System.Windows.Media.Color borderColor = System.Windows.Media.Color.FromArgb(220, 255, 180, 0);
+        System.Windows.Media.Color dimBorderColor = System.Windows.Media.Color.FromArgb(80, 255, 180, 0);
+
+        foreach (TemplateRegion region in template.Regions)
+        {
+            double regionLeft = region.RatioLeft * selWidth;
+            double regionTop = region.RatioTop * selHeight;
+            double regionWidth = region.RatioWidth * selWidth;
+            double regionHeight = region.RatioHeight * selHeight;
+
+            if (regionWidth < 1 || regionHeight < 1)
+                continue;
+
+            bool isReferenced = referencedRegions.Count == 0 || referencedRegions.Contains(region.RegionNumber);
+            Border regionBorder = new()
+            {
+                Width = regionWidth,
+                Height = regionHeight,
+                BorderBrush = new SolidColorBrush(isReferenced ? borderColor : dimBorderColor),
+                BorderThickness = new Thickness(1.5),
+            };
+
+            Canvas.SetLeft(regionBorder, regionLeft);
+            Canvas.SetTop(regionBorder, regionTop);
+            templateOverlayCanvas.Children.Add(regionBorder);
+        }
+
+        TemplateOverlayHost.Children.Add(templateOverlayCanvas);
+    }
+
     private void GetDpiAdjustedRegionOfSelectBorder(out DpiScale dpi, out double posLeft, out double posTop)
     {
         System.Windows.Point absPosPoint = this.GetAbsolutePosition();
@@ -541,11 +836,6 @@ private void NewGrabFrameMenuItem_Click(object sender, RoutedEventArgs e)
         bool isActive = CheckIfCheckingOrUnchecking(sender);
         WindowUtilities.FullscreenKeyDown(Key.G, isActive);
         SelectSingleToggleButton(sender);
-
-        // null out any zoom/scaling because it does not translate into GF Size
-        // TODO: when placing the Grab Frame consider zoom
-        BackgroundImage.RenderTransform = null;
-        edgePanTimer.Stop();
     }
 
     private void PanSelection(System.Windows.Point movingPoint)
@@ -577,9 +867,11 @@ private void PanSelection(System.Windows.Point movingPoint)
 
         clippingGeometry.Rect = new Rect(
             new System.Windows.Point(leftValue, topValue),
-            new System.Windows.Size(selectBorder.Width - 2, selectBorder.Height - 2));
-        Canvas.SetLeft(selectBorder, leftValue - 1);
-        Canvas.SetTop(selectBorder, topValue - 1);
+            new System.Windows.Size(selectBorder.Width, selectBorder.Height));
+        Canvas.SetLeft(selectBorder, leftValue);
+        Canvas.SetTop(selectBorder, topValue);
+
+        UpdateTemplateRegionOverlays(leftValue, topValue, selectBorder.Width, selectBorder.Height);
     }
 
     private void PlaceGrabFrameInSelectionRect()
@@ -590,15 +882,38 @@ private void PlaceGrabFrameInSelectionRect()
         // bottom bar and width of GrabFrame
         GetDpiAdjustedRegionOfSelectBorder(out DpiScale dpi, out double posLeft, out double posTop);
 
-        // TODO: The Grab Frame does not get the background image and position it.
-        // BackgroundImage should be passed to the GF and used as the image
-        // it would need to be positioned/cropped to the bounds of the GF
-
-        GrabFrame grabFrame = new()
+        // Crop the frozen background image to the selected region so the GrabFrame
+        // shows exactly what the user saw in the Fullscreen Grab (freeze continuity).
+        GrabFrame grabFrame;
+        if (BackgroundImage.Source is BitmapSource backgroundBitmap)
         {
-            Left = posLeft,
-            Top = posTop,
-        };
+            Matrix m = PresentationSource.FromVisual(this).CompositionTarget.TransformToDevice;
+            Rect selectionRect = GetCurrentSelectionRect();
+
+            if (TryGetBitmapCropRectForSelection(
+                selectionRect,
+                m,
+                BackgroundImage.RenderTransform,
+                backgroundBitmap.PixelWidth,
+                backgroundBitmap.PixelHeight,
+                out Int32Rect cropRect))
+            {
+                CroppedBitmap croppedBitmap = new(backgroundBitmap, cropRect);
+                croppedBitmap.Freeze();
+                grabFrame = new GrabFrame(croppedBitmap);
+            }
+            else
+            {
+                grabFrame = new GrabFrame();
+            }
+        }
+        else
+        {
+            grabFrame = new GrabFrame();
+        }
+
+        grabFrame.Left = posLeft;
+        grabFrame.Top = posTop;
 
         grabFrame.Left -= (2 / dpi.PixelsPerDip);
         grabFrame.Top -= (48 / dpi.PixelsPerDip);
@@ -628,233 +943,29 @@ private void RegionClickCanvas_ContextMenuOpening(object sender, ContextMenuEven
 
     private void RegionClickCanvas_MouseLeave(object sender, MouseEventArgs e)
     {
-        TopButtonsStackPanel.Visibility = Visibility.Collapsed;
+        UpdateTopToolbarVisibility(isPointerOverSelectionSurface: false);
     }
 
     private void RegionClickCanvas_MouseEnter(object sender, MouseEventArgs e)
     {
-        TopButtonsStackPanel.Visibility = Visibility.Visible;
+        UpdateTopToolbarVisibility(isPointerOverSelectionSurface: true);
     }
 
     private void RegionClickCanvas_MouseDown(object sender, MouseButtonEventArgs e)
     {
         if (e.RightButton == MouseButtonState.Pressed)
             return;
-
-        isSelecting = true;
-        TopButtonsStackPanel.Visibility = Visibility.Collapsed;
-        RegionClickCanvas.CaptureMouse();
-        CursorClipper.ClipCursor(this);
-        clickedPoint = e.GetPosition(this);
-        selectBorder.Height = 2;
-        selectBorder.Width = 2;
-
-        dpiScale = VisualTreeHelper.GetDpi(this);
-
-        try { RegionClickCanvas.Children.Remove(selectBorder); } catch (Exception) { }
-
-        selectBorder.BorderThickness = new Thickness(2);
-        System.Windows.Media.Color borderColor = System.Windows.Media.Color.FromArgb(255, 40, 118, 126);
-        selectBorder.BorderBrush = new SolidColorBrush(borderColor);
-        _ = RegionClickCanvas.Children.Add(selectBorder);
-        Canvas.SetLeft(selectBorder, clickedPoint.X);
-        Canvas.SetTop(selectBorder, clickedPoint.Y);
-
-        WindowUtilities.GetMousePosition(out System.Windows.Point mousePoint);
-        foreach (DisplayInfo? screen in DisplayInfo.AllDisplayInfos)
-        {
-            Rect bound = screen.ScaledBounds();
-            if (bound.Contains(mousePoint))
-                CurrentScreen = screen;
-        }
+        HandleRegionCanvasMouseDown(e);
     }
 
     private void RegionClickCanvas_MouseMove(object sender, MouseEventArgs e)
     {
-        if (!isSelecting)
-            return;
-
-        System.Windows.Point movingPoint = e.GetPosition(this);
-
-        if (Keyboard.Modifiers == ModifierKeys.Shift)
-        {
-            PanSelection(movingPoint);
-            return;
-        }
-
-        isShiftDown = false;
-
-        double left = Math.Min(clickedPoint.X, movingPoint.X);
-        double top = Math.Min(clickedPoint.Y, movingPoint.Y);
-
-        selectBorder.Height = Math.Max(clickedPoint.Y, movingPoint.Y) - top;
-        selectBorder.Width = Math.Max(clickedPoint.X, movingPoint.X) - left;
-        selectBorder.Height += 2;
-        selectBorder.Width += 2;
-
-        clippingGeometry.Rect = new Rect(
-            new System.Windows.Point(left, top),
-            new System.Windows.Size(selectBorder.Width - 2, selectBorder.Height - 2));
-        Canvas.SetLeft(selectBorder, left - 1);
-        Canvas.SetTop(selectBorder, top - 1);
+        HandleRegionCanvasMouseMove(e);
     }
 
     private async void RegionClickCanvas_MouseUp(object sender, MouseButtonEventArgs e)
     {
-        if (!isSelecting)
-            return;
-
-        isSelecting = false;
-        CurrentScreen = null;
-        CursorClipper.UnClipCursor();
-        RegionClickCanvas.ReleaseMouseCapture();
-        clippingGeometry.Rect = new Rect(
-            new System.Windows.Point(0, 0),
-            new System.Windows.Size(0, 0));
-
-        System.Windows.Point movingPoint = e.GetPosition(this);
-        Matrix m = PresentationSource.FromVisual(this).CompositionTarget.TransformToDevice;
-        movingPoint.X *= m.M11;
-        movingPoint.Y *= m.M22;
-
-        movingPoint.X = Math.Round(movingPoint.X);
-        movingPoint.Y = Math.Round(movingPoint.Y);
-
-        double xDimScaled = Canvas.GetLeft(selectBorder) * m.M11;
-        double yDimScaled = Canvas.GetTop(selectBorder) * m.M22;
-
-        Rectangle regionScaled = new(
-            (int)xDimScaled,
-            (int)yDimScaled,
-            (int)(selectBorder.Width * m.M11),
-            (int)(selectBorder.Height * m.M22));
-
-        TextFromOCR = string.Empty;
-
-        if (NewGrabFrameMenuItem.IsChecked is true)
-        {
-            PlaceGrabFrameInSelectionRect();
-            return;
-        }
-
-        try { RegionClickCanvas.Children.Remove(selectBorder); } catch { }
-
-        if (LanguagesComboBox.SelectedItem is not ILanguage selectedOcrLang)
-            selectedOcrLang = LanguageUtilities.GetOCRLanguage();
-
-        bool isSmallClick = (selectBorder.Width < 3 || selectBorder.Height < 3);
-
-        bool isSingleLine = SingleLineMenuItem is not null && SingleLineMenuItem.IsChecked;
-        bool isTable = TableMenuItem is not null && TableMenuItem.IsChecked;
-
-        if (isSmallClick)
-        {
-            BackgroundBrush.Opacity = 0;
-            TextFromOCR = await OcrUtilities.GetClickedWordAsync(this, new System.Windows.Point(xDimScaled, yDimScaled), selectedOcrLang);
-        }
-        else if (isTable)
-            TextFromOCR = await OcrUtilities.GetRegionsTextAsTableAsync(this, regionScaled, selectedOcrLang);
-        else
-            TextFromOCR = await OcrUtilities.GetRegionsTextAsync(this, regionScaled, selectedOcrLang);
-
-        if (DefaultSettings.UseHistory && !isSmallClick)
-        {
-            GetDpiAdjustedRegionOfSelectBorder(out _, out double posLeft, out double posTop);
-
-            Rect historyRect = new()
-            {
-                X = posLeft,
-                Y = posTop,
-                Width = selectBorder.Width,
-                Height = selectBorder.Height,
-            };
-
-            historyInfo = new()
-            {
-                ID = Guid.NewGuid().ToString(),
-                DpiScaleFactor = m.M11,
-                LanguageTag = LanguageUtilities.GetLanguageTag(selectedOcrLang),
-                LanguageKind = LanguageUtilities.GetLanguageKind(selectedOcrLang),
-                CaptureDateTime = DateTimeOffset.Now,
-                PositionRect = historyRect,
-                IsTable = TableToggleButton.IsChecked!.Value,
-                TextContent = TextFromOCR,
-                ImageContent = Singleton<HistoryService>.Instance.CachedBitmap,
-                SourceMode = TextGrabMode.Fullscreen,
-            };
-        }
-
-        if (string.IsNullOrWhiteSpace(TextFromOCR))
-        {
-            BackgroundBrush.Opacity = DefaultSettings.FsgShadeOverlay ? .2 : 0.0;
-            TopButtonsStackPanel.Visibility = Visibility.Visible;
-            return;
-        }
-
-        // Execute enabled post-grab actions dynamically
-        if (NextStepDropDownButton.Flyout is ContextMenu contextMenu)
-        {
-            bool shouldInsert = false;
-
-            foreach (object item in contextMenu.Items)
-            {
-                if (item is MenuItem menuItem && menuItem.IsChecked && menuItem.Tag is ButtonInfo action)
-                {
-                    // Special handling for Insert action - defer until after window closes
-                    if (action.ClickEvent == "Insert_Click")
-                    {
-                        shouldInsert = true;
-                        continue;
-                    }
-
-                    // Execute the action
-                    TextFromOCR = await PostGrabActionManager.ExecutePostGrabAction(action, TextFromOCR);
-                }
-            }
-
-            // Handle insert after all other actions
-            if (shouldInsert && !DefaultSettings.TryInsert)
-            {
-                // Store for later execution after window closes
-                string textToInsert = TextFromOCR;
-                _ = Task.Run(async () =>
-                {
-                    await Task.Delay(100); // Small delay to ensure window is closed
-                    await WindowUtilities.TryInsertString(textToInsert);
-                });
-            }
-        }
-
-        if (SendToEditTextToggleButton.IsChecked is true
-            && destinationTextBox is null)
-        {
-            // Only open ETW if we're not doing a web search
-            bool isWebSearch = false;
-            if (NextStepDropDownButton.Flyout is ContextMenu cm)
-            {
-                foreach (object item in cm.Items)
-                {
-                    if (item is MenuItem mi && mi.IsChecked && mi.Tag is ButtonInfo act && act.ClickEvent == "WebSearch_Click")
-                    {
-                        isWebSearch = true;
-                        break;
-                    }
-                }
-            }
-
-            if (!isWebSearch)
-            {
-                EditTextWindow etw = WindowUtilities.OpenOrActivateWindow<EditTextWindow>();
-                destinationTextBox = etw.PassedTextControl;
-            }
-        }
-
-        OutputUtilities.HandleTextFromOcr(
-            TextFromOCR,
-            isSingleLine,
-            isTable,
-            destinationTextBox);
-        WindowUtilities.CloseAllFullscreenGrabs();
+        await HandleRegionCanvasMouseUpAsync(e);
     }
 
     private void SendToEditTextToggleButton_Click(object sender, RoutedEventArgs e)
@@ -992,6 +1103,13 @@ private async void Window_Loaded(object sender, RoutedEventArgs e)
 
         if (IsMouseOver)
             TopButtonsStackPanel.Visibility = Visibility.Visible;
+
+        FsgSelectionStyle selectionStyle = FsgSelectionStyle.Region;
+        if (!string.IsNullOrWhiteSpace(DefaultSettings.FsgSelectionStyle))
+            Enum.TryParse(DefaultSettings.FsgSelectionStyle, true, out selectionStyle);
+
+        ApplySelectionStyle(selectionStyle, persistToSettings: false);
+        windowSelectionTimer.Start();
     }
 
     private void DisposeBitmapSource(System.Windows.Controls.Image image)
@@ -1007,6 +1125,8 @@ private void Window_Unloaded(object sender, RoutedEventArgs e)
     {
         edgePanTimer.Stop();
         edgePanTimer.Tick -= EdgePanTimer_Tick;
+        windowSelectionTimer.Stop();
+        windowSelectionTimer.Tick -= WindowSelectionTimer_Tick;
 
         DisposeBitmapSource(BackgroundImage);
 
@@ -1017,11 +1137,14 @@ private void Window_Unloaded(object sender, RoutedEventArgs e)
         if (RegionClickCanvas.Children.Contains(selectBorder))
             RegionClickCanvas.Children.Remove(selectBorder);
 
+        if (SelectionOutlineHost.Children.Contains(selectionOutlineBorder))
+            SelectionOutlineHost.Children.Remove(selectionOutlineBorder);
+
         // Clean up dynamically created post-grab action menu items
         if (NextStepDropDownButton.Flyout is ContextMenu contextMenu)
         {
             contextMenu.PreviewKeyDown -= FullscreenGrab_KeyDown;
-            
+
             foreach (object item in contextMenu.Items)
             {
                 if (item is MenuItem menuItem)
@@ -1043,7 +1166,7 @@ private void Window_Unloaded(object sender, RoutedEventArgs e)
                     }
                 }
             }
-            
+
             contextMenu.Items.Clear();
         }
 
@@ -1066,6 +1189,10 @@ private void Window_Unloaded(object sender, RoutedEventArgs e)
 
         SingleLineMenuItem.Click -= SingleLineMenuItem_Click;
         FreezeMenuItem.Click -= FreezeMenuItem_Click;
+        RegionSelectionMenuItem.Click -= SelectionStyleMenuItem_Click;
+        WindowSelectionMenuItem.Click -= SelectionStyleMenuItem_Click;
+        FreeformSelectionMenuItem.Click -= SelectionStyleMenuItem_Click;
+        AdjustAfterSelectionMenuItem.Click -= SelectionStyleMenuItem_Click;
         NewGrabFrameMenuItem.Click -= NewGrabFrameMenuItem_Click;
         SendToEtwMenuItem.Click -= NewEditTextMenuItem_Click;
         SettingsMenuItem.Click -= SettingsMenuItem_Click;
@@ -1074,10 +1201,12 @@ private void Window_Unloaded(object sender, RoutedEventArgs e)
 
         LanguagesComboBox.SelectionChanged -= LanguagesComboBox_SelectionChanged;
         LanguagesComboBox.PreviewMouseDown -= LanguagesComboBox_PreviewMouseDown;
+        SelectionStyleComboBox.SelectionChanged -= SelectionStyleComboBox_SelectionChanged;
 
         SingleLineToggleButton.Click -= SingleLineMenuItem_Click;
         FreezeToggleButton.Click -= FreezeMenuItem_Click;
         NewGrabFrameToggleButton.Click -= NewGrabFrameMenuItem_Click;
+        AcceptSelectionButton.Click -= AcceptSelectionButton_Click;
         SendToEditTextToggleButton.Click -= SendToEditTextToggleButton_Click;
         TableToggleButton.Click -= TableToggleButton_Click;
         StandardModeToggleButton.Click -= StandardModeToggleButton_Click;
@@ -1136,15 +1265,13 @@ private void TableToggleButton_Click(object? sender = null, RoutedEventArgs? e =
 
     private void PostActionMenuItem_Click(object sender, RoutedEventArgs e)
     {
-        // Save check state for LastUsed tracking
-        if (sender is MenuItem menuItem 
-            && menuItem.Tag is ButtonInfo action
-            && action.DefaultCheckState == DefaultCheckState.LastUsed)
+        if (sender is not MenuItem menuItem)
         {
-            PostGrabActionManager.SaveCheckState(action, menuItem.IsChecked);
+            RefreshPostGrabActionVisuals();
+            return;
         }
 
-        CheckIfAnyPostActionsSelected();
+        SynchronizePostGrabActionSelection(menuItem, menuItem.IsChecked);
     }
     #endregion Methods
 
@@ -1278,13 +1405,6 @@ private void PanBackgroundImage(double deltaX, double deltaY, TransformGroup tra
 
     private void RegionClickCanvas_PreviewMouseWheel(object sender, MouseWheelEventArgs e)
     {
-        if (NewGrabFrameMenuItem.IsChecked)
-        {
-            BackgroundImage.RenderTransform = null;
-            edgePanTimer.Stop();
-            return;
-        }
-
         System.Windows.Point point = Mouse.GetPosition(this);
 
         if (BackgroundImage.RenderTransform is TransformGroup transformGroup)
@@ -1362,6 +1482,64 @@ private void HidePostGrabActions_Click(object sender, RoutedEventArgs e)
             menu.IsOpen = false;
     }
 
+    internal static bool TryGetBitmapCropRectForSelection(
+        Rect selectionRect,
+        Matrix transformToDevice,
+        Transform? backgroundRenderTransform,
+        int bitmapPixelWidth,
+        int bitmapPixelHeight,
+        out Int32Rect cropRect)
+    {
+        cropRect = default;
+
+        if (selectionRect.IsEmpty
+            || selectionRect.Width <= 0
+            || selectionRect.Height <= 0
+            || bitmapPixelWidth <= 0
+            || bitmapPixelHeight <= 0)
+        {
+            return false;
+        }
+
+        Matrix selectionToBackground = backgroundRenderTransform?.Value ?? Matrix.Identity;
+        if (selectionToBackground.HasInverse)
+            selectionToBackground.Invert();
+        else
+            selectionToBackground = Matrix.Identity;
+
+        Point[] backgroundPoints =
+        [
+            selectionToBackground.Transform(selectionRect.TopLeft),
+            selectionToBackground.Transform(new Point(selectionRect.Right, selectionRect.Top)),
+            selectionToBackground.Transform(new Point(selectionRect.Left, selectionRect.Bottom)),
+            selectionToBackground.Transform(selectionRect.BottomRight)
+        ];
+
+        Point[] bitmapPoints =
+        [
+            transformToDevice.Transform(backgroundPoints[0]),
+            transformToDevice.Transform(backgroundPoints[1]),
+            transformToDevice.Transform(backgroundPoints[2]),
+            transformToDevice.Transform(backgroundPoints[3])
+        ];
+
+        double left = bitmapPoints.Min(static point => point.X);
+        double top = bitmapPoints.Min(static point => point.Y);
+        double right = bitmapPoints.Max(static point => point.X);
+        double bottom = bitmapPoints.Max(static point => point.Y);
+
+        int cropLeft = Math.Max(0, (int)Math.Floor(left));
+        int cropTop = Math.Max(0, (int)Math.Floor(top));
+        int cropRight = Math.Min(bitmapPixelWidth, (int)Math.Ceiling(right));
+        int cropBottom = Math.Min(bitmapPixelHeight, (int)Math.Ceiling(bottom));
+
+        if (cropRight <= cropLeft || cropBottom <= cropTop)
+            return false;
+
+        cropRect = new Int32Rect(cropLeft, cropTop, cropRight - cropLeft, cropBottom - cropTop);
+        return true;
+    }
+
     private void EditPostGrabActions_Click(object sender, RoutedEventArgs e)
     {
         PostGrabActionEditor postGrabActionEditor = new();
diff --git a/Text-Grab/Views/GrabFrame.xaml b/Text-Grab/Views/GrabFrame.xaml
index fecddb79..a768d5ea 100644
--- a/Text-Grab/Views/GrabFrame.xaml
+++ b/Text-Grab/Views/GrabFrame.xaml
@@ -17,8 +17,8 @@
     AllowDrop="True"
     AllowsTransparency="True"
     Background="Transparent"
-    BorderBrush="Gray"
-    BorderThickness="0.2"
+    BorderBrush="{ui:ThemeResource ApplicationBackgroundBrush}"
+    BorderThickness="1"
     Closed="Window_Closed"
     Closing="GrabFrameWindow_Closing"
     Deactivated="GrabFrameWindow_Deactivated"
@@ -38,14 +38,6 @@
     mc:Ignorable="d">
     <Window.Resources>
         <BitmapImage x:Key="TextGrabIcon" UriSource="/Text-Grab;component/Images/TealSelect40.png" />
-
-        <Style x:Key="SymbolTextStyle" TargetType="TextBlock">
-            <Setter Property="HorizontalAlignment" Value="Center" />
-            <Setter Property="VerticalAlignment" Value="Center" />
-            <Setter Property="FontFamily" Value="Segoe MDL2 Assets" />
-            <Setter Property="FontSize" Value="16" />
-            <Setter Property="Margin" Value="4" />
-        </Style>
     </Window.Resources>
 
     <Window.CommandBindings>
@@ -84,7 +76,7 @@
             CaptionHeight="32"
             CornerRadius="18,18,2,18"
             GlassFrameThickness="0"
-            ResizeBorderThickness="5" />
+            ResizeBorderThickness="8" />
     </WindowChrome.WindowChrome>
     <Border
         BorderBrush="{ui:ThemeResource ApplicationBackgroundBrush}"
@@ -92,8 +84,9 @@
         ClipToBounds="True">
         <Grid ClipToBounds="False">
             <Grid.RowDefinitions>
-                <RowDefinition Height="32" />
+                <RowDefinition Height="34" />
                 <RowDefinition Height="*" />
+                <RowDefinition Height="Auto" />
                 <RowDefinition Height="auto" />
             </Grid.RowDefinitions>
             <Grid
@@ -230,6 +223,10 @@
                             Header="Grab text as Single Line"
                             InputGestureText="Ctrl + Shift + G" />
                         <Separator />
+                        <MenuItem
+                            Name="ManageGrabTemplatesMenuItem"
+                            Click="ManageGrabTemplates_Click"
+                            Header="Manage Grab _Templates..." />
                         <MenuItem
                             Name="SettingsMenuItem"
                             Click="SettingsBTN_Click"
@@ -492,135 +489,190 @@
                                     MouseDown="RectanglesCanvas_MouseDown"
                                     MouseMove="RectanglesCanvas_MouseMove"
                                     MouseUp="RectanglesCanvas_MouseUp">
-                                <Canvas.ContextMenu>
-                                    <ContextMenu>
-                                        <MenuItem
-                                            Command="{x:Static local:GrabFrame.PasteCommand}"
-                                            Header="Paste Image"
-                                            InputGestureText="Ctrl + Shift + V" />
-                                        <MenuItem
-                                            Click="OpenImageMenuItem_Click"
-                                            Header="Open Image..."
-                                            InputGestureText="Ctrl + O" />
-                                        <Separator />
-                                        <MenuItem
-                                            x:Name="CopyText"
-                                            Click="CopyText_Click"
-                                            Header="Copy Text" />
-                                        <Separator />
-                                        <MenuItem
-                                            x:Name="AspectRationMI"
-                                            Checked="AspectRationMI_Checked"
-                                            Header="Maintain Aspect Ratio"
-                                            IsCheckable="True"
-                                            IsChecked="True"
-                                            Unchecked="AspectRationMI_Checked" />
-                                        <MenuItem
-                                            x:Name="FreezeMI"
-                                            Click="FreezeMI_Click"
-                                            Header="Toggle Freeze"
-                                            InputGestureText="F" />
-                                        <Separator />
-                                        <MenuItem
-                                            x:Name="TryToNumberMenuItem"
-                                            Click="TryToNumberMenuItem_Click"
-                                            Header="Try To Make _Numbers" />
-                                        <MenuItem
-                                            x:Name="TryToAlphaMenuItem"
-                                            Click="TryToAlphaMenuItem_Click"
-                                            Header="Try To Make _Letters" />
-                                        <MenuItem
-                                            Command="{x:Static local:GrabFrame.MergeWordsCommand}"
-                                            Header="Merge Word Borders"
-                                            InputGestureText="Ctrl + M" />
-                                        <MenuItem
-                                            Command="{x:Static local:GrabFrame.DeleteWordsCommand}"
-                                            Header="_Delete selected words"
-                                            InputGestureText="Del" />
-                                    </ContextMenu>
-                                </Canvas.ContextMenu>
-                            </Canvas>
-                                        </Grid>
-                                    </Viewbox>
-                                    </controls:ZoomBorder>
-                                    <Border
-                                        x:Name="TranslationProgressBorder"
-                                        Height="40"
-                                        Margin="8"
-                                        VerticalAlignment="Bottom"
-                                        Background="{DynamicResource SolidBackgroundFillColorBaseBrush}"
-                                        BorderBrush="{ui:ThemeResource ControlStrokeColorDefaultBrush}"
-                                        BorderThickness="1"
-                                        CornerRadius="6"
-                                        Visibility="Collapsed">
-                                        <Border.Effect>
-                                            <DropShadowEffect
-                                                BlurRadius="8"
-                                                Direction="270"
-                                                Opacity="0.3"
-                                                ShadowDepth="2"
-                                                Color="Black" />
-                                        </Border.Effect>
-                                        <Grid Margin="8,0">
-                                            <Grid.ColumnDefinitions>
-                                                <ColumnDefinition Width="Auto" />
-                                                <ColumnDefinition Width="*" />
-                                                <ColumnDefinition Width="Auto" />
-                                                <ColumnDefinition Width="Auto" />
-                                            </Grid.ColumnDefinitions>
-                                            <ui:SymbolIcon
-                                                Grid.Column="0"
-                                                Margin="0,0,12,0"
-                                                VerticalAlignment="Center"
-                                                Foreground="{ui:ThemeResource AccentTextFillColorPrimaryBrush}"
-                                                Symbol="LocalLanguage24" />
-                                            <StackPanel
-                                                Grid.Column="1"
-                                                VerticalAlignment="Center"
-                                                Orientation="Vertical">
-                                                <TextBlock
-                                                    x:Name="TranslationProgressText"
-                                                    Margin="0,0,0,2"
-                                                    FontSize="12"
-                                                    FontWeight="SemiBold"
-                                                    Foreground="{ui:ThemeResource TextFillColorPrimaryBrush}"
-                                                    Text="Translating..." />
-                                                <ProgressBar
-                                                    x:Name="TranslationProgressBar"
-                                                    Height="6"
-                                                    Maximum="100"
-                                                    Minimum="0"
-                                                    Value="0" />
-                                            </StackPanel>
-                                            <TextBlock
-                                                x:Name="TranslationCountText"
-                                                Grid.Column="2"
-                                                Margin="12,0,8,0"
-                                                VerticalAlignment="Center"
-                                                FontSize="11"
-                                                Foreground="{ui:ThemeResource TextFillColorSecondaryBrush}"
-                                                Text="0/0" />
-                                            <Button
-                                                x:Name="CancelTranslationButton"
-                                                Grid.Column="3"
-                                                Width="28"
-                                                Height="28"
-                                                Padding="0"
-                                                VerticalAlignment="Center"
-                                                Background="Transparent"
-                                                BorderThickness="0"
-                                                Click="CancelTranslationButton_Click"
-                                                ToolTip="Cancel translation">
-                                                <ui:SymbolIcon
-                                                    FontSize="16"
-                                                    Foreground="{ui:ThemeResource TextFillColorSecondaryBrush}"
-                                                    Symbol="Dismiss24" />
-                                            </Button>
-                                        </Grid>
-                                    </Border>
-                                </Grid>
-                        </Border>
-            <Border Grid.Row="2" Background="{ui:ThemeResource ApplicationBackgroundBrush}">
+                                    <Canvas.ContextMenu>
+                                        <ContextMenu>
+                                            <MenuItem
+                                                Command="{x:Static local:GrabFrame.PasteCommand}"
+                                                Header="Paste Image"
+                                                InputGestureText="Ctrl + Shift + V" />
+                                            <MenuItem
+                                                Click="OpenImageMenuItem_Click"
+                                                Header="Open Image..."
+                                                InputGestureText="Ctrl + O" />
+                                            <Separator />
+                                            <MenuItem
+                                                x:Name="CopyText"
+                                                Click="CopyText_Click"
+                                                Header="Copy Text" />
+                                            <Separator />
+                                            <MenuItem
+                                                x:Name="AspectRationMI"
+                                                Checked="AspectRationMI_Checked"
+                                                Header="Maintain Aspect Ratio"
+                                                IsCheckable="True"
+                                                IsChecked="True"
+                                                Unchecked="AspectRationMI_Checked" />
+                                            <MenuItem
+                                                x:Name="FreezeMI"
+                                                Click="FreezeMI_Click"
+                                                Header="Toggle Freeze"
+                                                InputGestureText="F" />
+                                            <Separator />
+                                            <MenuItem
+                                                x:Name="TryToNumberMenuItem"
+                                                Click="TryToNumberMenuItem_Click"
+                                                Header="Try To Make _Numbers" />
+                                            <MenuItem
+                                                x:Name="TryToAlphaMenuItem"
+                                                Click="TryToAlphaMenuItem_Click"
+                                                Header="Try To Make _Letters" />
+                                            <MenuItem
+                                                Command="{x:Static local:GrabFrame.MergeWordsCommand}"
+                                                Header="Merge Word Borders"
+                                                InputGestureText="Ctrl + M" />
+                                            <MenuItem
+                                                Command="{x:Static local:GrabFrame.DeleteWordsCommand}"
+                                                Header="_Delete selected words"
+                                                InputGestureText="Del" />
+                                        </ContextMenu>
+                                    </Canvas.ContextMenu>
+                                </Canvas>
+                            </Grid>
+                        </Viewbox>
+                    </controls:ZoomBorder>
+                    <Border
+                        x:Name="TranslationProgressBorder"
+                        Height="40"
+                        Margin="8"
+                        VerticalAlignment="Bottom"
+                        Background="{DynamicResource SolidBackgroundFillColorBaseBrush}"
+                        BorderBrush="{ui:ThemeResource ControlStrokeColorDefaultBrush}"
+                        BorderThickness="1"
+                        CornerRadius="6"
+                        Visibility="Collapsed">
+                        <Border.Effect>
+                            <DropShadowEffect
+                                BlurRadius="8"
+                                Direction="270"
+                                Opacity="0.3"
+                                ShadowDepth="2"
+                                Color="Black" />
+                        </Border.Effect>
+                        <Grid Margin="8,0">
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="Auto" />
+                                <ColumnDefinition Width="*" />
+                                <ColumnDefinition Width="Auto" />
+                                <ColumnDefinition Width="Auto" />
+                            </Grid.ColumnDefinitions>
+                            <ui:SymbolIcon
+                                Grid.Column="0"
+                                Margin="0,0,12,0"
+                                VerticalAlignment="Center"
+                                Foreground="{ui:ThemeResource AccentTextFillColorPrimaryBrush}"
+                                Symbol="LocalLanguage24" />
+                            <StackPanel
+                                Grid.Column="1"
+                                VerticalAlignment="Center"
+                                Orientation="Vertical">
+                                <TextBlock
+                                    x:Name="TranslationProgressText"
+                                    Margin="0,0,0,2"
+                                    FontSize="12"
+                                    FontWeight="SemiBold"
+                                    Foreground="{ui:ThemeResource TextFillColorPrimaryBrush}"
+                                    Text="Translating..." />
+                                <ProgressBar
+                                    x:Name="TranslationProgressBar"
+                                    Height="6"
+                                    Maximum="100"
+                                    Minimum="0"
+                                    Value="0" />
+                            </StackPanel>
+                            <TextBlock
+                                x:Name="TranslationCountText"
+                                Grid.Column="2"
+                                Margin="12,0,8,0"
+                                VerticalAlignment="Center"
+                                FontSize="11"
+                                Foreground="{ui:ThemeResource TextFillColorSecondaryBrush}"
+                                Text="0/0" />
+                            <Button
+                                x:Name="CancelTranslationButton"
+                                Grid.Column="3"
+                                Width="28"
+                                Height="28"
+                                Padding="0"
+                                VerticalAlignment="Center"
+                                Background="Transparent"
+                                BorderThickness="0"
+                                Click="CancelTranslationButton_Click"
+                                ToolTip="Cancel translation">
+                                <ui:SymbolIcon
+                                    FontSize="16"
+                                    Foreground="{ui:ThemeResource TextFillColorSecondaryBrush}"
+                                    Symbol="Dismiss24" />
+                            </Button>
+                        </Grid>
+                    </Border>
+                </Grid>
+            </Border>
+            <!--  Template Save Panel (collapsed by default, shown when Save as Template is toggled)  -->
+            <Border
+                x:Name="TemplateSavePanel"
+                Grid.Row="2"
+                Background="{ui:ThemeResource ApplicationBackgroundBrush}"
+                BorderBrush="{ui:ThemeResource ControlStrokeColorDefaultBrush}"
+                BorderThickness="0,1,0,0"
+                Visibility="Collapsed">
+                <Grid Margin="8,6">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="160" />
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="*" />
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="Auto" />
+                    </Grid.ColumnDefinitions>
+                    <TextBlock
+                        Grid.Column="0"
+                        Margin="0,0,6,0"
+                        VerticalAlignment="Center"
+                        Text="Template Name:" />
+                    <TextBox
+                        x:Name="TemplateNameBox"
+                        Grid.Column="1"
+                        Padding="4,2"
+                        VerticalContentAlignment="Center" />
+                    <TextBlock
+                        Grid.Column="2"
+                        Margin="8,0,6,0"
+                        VerticalAlignment="Center"
+                        Text="Output (type { to pick):"
+                        ToolTip="Type { to insert a region chip. Plain text is also supported." />
+                    <controls:InlinePickerRichTextBox
+                        x:Name="TemplateOutputBox"
+                        Grid.Column="3"
+                        VerticalAlignment="Center"
+                        AcceptsReturn="True"
+                        AcceptsTab="True"
+                        TextChanged="TemplateOutputBox_TextChanged"
+                        ToolTip="Type { to open the region picker. Plain text also supported." />
+                    <Button
+                        Grid.Column="4"
+                        Margin="8,0,4,0"
+                        Padding="8,4"
+                        Click="SaveTemplateSave_Click"
+                        Content="Save Template" />
+                    <Button
+                        Grid.Column="5"
+                        Padding="8,4"
+                        Click="SaveTemplateCancel_Click"
+                        Content="Cancel" />
+                </Grid>
+            </Border>
+
+            <Border Grid.Row="3" Background="{ui:ThemeResource ApplicationBackgroundBrush}">
                 <Grid
                     Height="30"
                     Margin="6"
@@ -826,6 +878,17 @@
                             IsSymbol="True"
                             ToolTip="Open Text Grab Settings"
                             Visibility="Collapsed" />
+
+                        <ToggleButton
+                            x:Name="SaveAsTemplateBTN"
+                            Width="30"
+                            Height="30"
+                            Margin="6,0,0,0"
+                            Click="SaveAsTemplate_Click"
+                            Style="{StaticResource ToggleSymbolButton}"
+                            ToolTip="Save current Ctrl+drag regions as a Grab Template">
+                            <ui:SymbolIcon Symbol="DocumentSave24" />
+                        </ToggleButton>
                     </StackPanel>
 
                     <controls:CollapsibleButton
diff --git a/Text-Grab/Views/GrabFrame.xaml.cs b/Text-Grab/Views/GrabFrame.xaml.cs
index f9db5caa..9bb01ab4 100644
--- a/Text-Grab/Views/GrabFrame.xaml.cs
+++ b/Text-Grab/Views/GrabFrame.xaml.cs
@@ -54,6 +54,8 @@ public partial class GrabFrame : Window
     private TextBox? destinationTextBox;
     private ImageSource? frameContentImageSource;
     private HistoryInfo? historyItem;
+    private readonly GrabTemplate? _editingTemplate;
+    private string? _currentImagePath;
     private bool hasLoadedImageSource = false;
     private bool IsDragOver = false;
     private bool isDrawing = false;
@@ -136,6 +138,130 @@ public GrabFrame(string imagePath)
         Loaded += async (s, e) => await TryLoadImageFromPath(absolutePath);
     }
 
+    /// <summary>
+    /// Creates a GrabFrame pre-loaded with a frozen image cropped from a Fullscreen Grab selection.
+    /// The frame opens in freeze mode showing the provided bitmap and immediately runs OCR.
+    /// </summary>
+    /// <param name="frozenImage">The cropped bitmap to display as the initial frozen background.</param>
+    public GrabFrame(BitmapSource frozenImage)
+    {
+        StandardInitialize();
+
+        ShouldSaveOnClose = true;
+        frameContentImageSource = frozenImage;
+        hasLoadedImageSource = true;
+
+        Loaded += (s, e) =>
+        {
+            FreezeToggleButton.IsChecked = true;
+            FreezeGrabFrame();
+            reDrawTimer.Start();
+        };
+    }
+
+    /// <summary>
+    /// Opens GrabFrame in template editing mode with existing regions pre-loaded.
+    /// </summary>
+    /// <param name="template">The template to edit.</param>
+    public GrabFrame(GrabTemplate template)
+    {
+        StandardInitialize();
+
+        ShouldSaveOnClose = false;
+        _editingTemplate = template;
+        Title = $"Edit Template: {template.Name}";
+
+        Loaded += async (s, e) => await LoadTemplateForEditing(template);
+    }
+
+    private async Task LoadTemplateForEditing(GrabTemplate template)
+    {
+        TemplateNameBox.Text = template.Name;
+
+        SaveAsTemplateBTN.IsChecked = true;
+        TemplateSavePanel.Visibility = Visibility.Visible;
+
+        if (!string.IsNullOrEmpty(template.SourceImagePath) && File.Exists(template.SourceImagePath))
+        {
+            await TryLoadImageFromPath(template.SourceImagePath);
+            reDrawTimer.Stop();
+        }
+        else
+        {
+            // No reference image — freeze into a clean empty canvas without capturing the screen
+            GrabFrameImage.Opacity = 0;
+            FreezeToggleButton.IsChecked = true;
+            FreezeToggleButton.Visibility = Visibility.Collapsed;
+            Topmost = false;
+            Background = new SolidColorBrush(Colors.DimGray);
+            RectanglesBorder.Background.Opacity = 0;
+            IsFreezeMode = true;
+        }
+
+        // Allow WPF to measure the canvas after the image loads
+        await Task.Delay(150);
+
+        double cw = RectanglesCanvas.ActualWidth;
+        double ch = RectanglesCanvas.ActualHeight;
+
+        if (cw <= 0) cw = template.ReferenceImageWidth;
+        if (ch <= 0) ch = template.ReferenceImageHeight;
+
+        foreach (TemplateRegion region in template.Regions.OrderBy(r => r.RegionNumber))
+        {
+            Rect abs = region.ToAbsoluteRect(cw, ch);
+
+            WordBorder wb = new()
+            {
+                Width = Math.Max(abs.Width, 10),
+                Height = Math.Max(abs.Height, 10),
+                Left = abs.X,
+                Top = abs.Y,
+                Word = region.Label,
+                OwnerGrabFrame = this,
+                MatchingBackground = new SolidColorBrush(Colors.Black),
+            };
+
+            wordBorders.Add(wb);
+            _ = RectanglesCanvas.Children.Add(wb);
+        }
+
+        EnterEditMode();
+        UpdateTemplateBadges();
+        UpdateTemplatePickerItems();
+
+        // For editing, also add picker items for the template's specific pattern configurations
+        // so SetSerializedText can match the exact placeholder values and recreate chips
+        if (template.PatternMatches.Count > 0)
+        {
+            List<InlinePickerItem> items = [.. TemplateOutputBox.ItemsSource ?? []];
+            foreach (TemplatePatternMatch pm in template.PatternMatches)
+            {
+                string displayLabel = $"{pm.PatternName} ({pm.MatchMode})";
+                string value = BuildPatternPlaceholderValue(pm);
+                // Only add if not already in the list (avoid duplicates with the default "first" items)
+                if (!items.Any(i => i.Value == value))
+                    items.Add(new InlinePickerItem(displayLabel, value, "Patterns"));
+            }
+            TemplateOutputBox.ItemsSource = items;
+        }
+
+        // Repopulate the output box AFTER ItemsSource is set so chips are recreated correctly
+        TemplateOutputBox.SetSerializedText(template.OutputTemplate);
+        reSearchTimer.Start();
+    }
+
+    private static string BuildPatternPlaceholderValue(TemplatePatternMatch config)
+    {
+        bool needsSeparator = config.MatchMode == "all"
+            || (config.MatchMode.Contains(',') && config.MatchMode.Split(',').Length > 1);
+
+        if (needsSeparator && config.Separator != ", ")
+            return $"{{p:{config.PatternName}:{config.MatchMode}:{config.Separator}}}";
+
+        return $"{{p:{config.PatternName}:{config.MatchMode}}}";
+    }
+
     private async Task LoadContentFromHistory(HistoryInfo history)
     {
         FrameText = history.TextContent;
@@ -154,11 +280,30 @@ private async Task LoadContentFromHistory(HistoryInfo history)
             return;
         }
 
+        history.ImageContent = bgBitmap;
         frameContentImageSource = ImageMethods.BitmapToImageSource(bgBitmap);
         hasLoadedImageSource = true;
         GrabFrameImage.Source = frameContentImageSource;
         FreezeGrabFrame();
 
+        if (history.PositionRect != Rect.Empty)
+        {
+            Left = history.PositionRect.Left;
+            Top = history.PositionRect.Top;
+
+            if (history.SourceMode == TextGrabMode.Fullscreen)
+            {
+                Size nonContentSize = GetGrabFrameNonContentSize();
+                Width = history.PositionRect.Width + nonContentSize.Width;
+                Height = history.PositionRect.Height + nonContentSize.Height;
+            }
+            else
+            {
+                Width = history.PositionRect.Width;
+                Height = history.PositionRect.Height;
+            }
+        }
+
         List<WordBorderInfo>? wbInfoList = null;
 
         if (!string.IsNullOrWhiteSpace(history.WordBorderInfoJson))
@@ -166,6 +311,8 @@ private async Task LoadContentFromHistory(HistoryInfo history)
 
         if (wbInfoList is not null && wbInfoList.Count > 0)
         {
+            ScaleHistoryWordBordersToCanvas(history, wbInfoList);
+
             foreach (WordBorderInfo info in wbInfoList)
             {
                 WordBorder wb = new(info)
@@ -186,26 +333,112 @@ private async Task LoadContentFromHistory(HistoryInfo history)
             ShouldSaveOnClose = true;
         }
 
-        if (history.PositionRect != Rect.Empty)
+        TableToggleButton.IsChecked = history.IsTable;
+
+        UpdateFrameText();
+    }
+
+    private Size GetGrabFrameNonContentSize()
+    {
+        const double defaultNonContentWidth = 4;
+        const double defaultNonContentHeight = 74;
+
+        UpdateLayout();
+
+        if (ActualWidth <= 1 || ActualHeight <= 1
+            || RectanglesBorder.ActualWidth <= 1 || RectanglesBorder.ActualHeight <= 1)
         {
-            Left = history.PositionRect.Left;
-            Top = history.PositionRect.Top;
-            Height = history.PositionRect.Height;
-            Width = history.PositionRect.Width;
+            return new Size(defaultNonContentWidth, defaultNonContentHeight);
+        }
 
-            if (history.SourceMode == TextGrabMode.Fullscreen)
-            {
-                int borderThickness = 2;
-                int titleBarHeight = 32;
-                int bottomBarHeight = 42;
-                Height += (titleBarHeight + bottomBarHeight);
-                Width += (2 * borderThickness);
-            }
+        double nonContentWidth = ActualWidth - RectanglesBorder.ActualWidth;
+        double nonContentHeight = ActualHeight - RectanglesBorder.ActualHeight;
+
+        if (!double.IsFinite(nonContentWidth) || nonContentWidth < 0 || nonContentWidth > 100)
+            nonContentWidth = defaultNonContentWidth;
+
+        if (!double.IsFinite(nonContentHeight) || nonContentHeight < 0 || nonContentHeight > 200)
+            nonContentHeight = defaultNonContentHeight;
+
+        return new Size(nonContentWidth, nonContentHeight);
+    }
+
+    private void ScaleHistoryWordBordersToCanvas(HistoryInfo history, List<WordBorderInfo> wbInfoList)
+    {
+        if (wbInfoList.Count == 0 || RectanglesCanvas.Width <= 0 || RectanglesCanvas.Height <= 0)
+            return;
+
+        Size savedContentSize = GetSavedHistoryContentSize(history);
+        if (savedContentSize.Width <= 0 || savedContentSize.Height <= 0)
+            return;
+
+        double scaleX = RectanglesCanvas.Width / savedContentSize.Width;
+        double scaleY = RectanglesCanvas.Height / savedContentSize.Height;
+        if (!double.IsFinite(scaleX) || !double.IsFinite(scaleY) || (scaleX <= 1.05 && scaleY <= 1.05))
+            return;
+
+        double maxRight = wbInfoList.Max(info => info.BorderRect.Right);
+        double maxBottom = wbInfoList.Max(info => info.BorderRect.Bottom);
+
+        // Scale only when saved word borders look like they were captured in
+        // the old window-content coordinate space rather than image-space.
+        if (maxRight > savedContentSize.Width * 1.1 || maxBottom > savedContentSize.Height * 1.1)
+            return;
+
+        foreach (WordBorderInfo info in wbInfoList)
+        {
+            Rect borderRect = info.BorderRect;
+            info.BorderRect = new Rect(
+                borderRect.Left * scaleX,
+                borderRect.Top * scaleY,
+                borderRect.Width * scaleX,
+                borderRect.Height * scaleY);
         }
+    }
 
-        TableToggleButton.IsChecked = history.IsTable;
+    private Size GetSavedHistoryContentSize(HistoryInfo history)
+    {
+        if (history.ImageContent is System.Drawing.Bitmap imageContentBitmap
+            && imageContentBitmap.Width > 0 && imageContentBitmap.Height > 0)
+        {
+            return new Size(imageContentBitmap.Width, imageContentBitmap.Height);
+        }
 
-        UpdateFrameText();
+        Rect positionRect = history.PositionRect;
+        if (positionRect == Rect.Empty || positionRect.Width <= 0 || positionRect.Height <= 0)
+            return new Size(0, 0);
+
+        if (history.SourceMode == TextGrabMode.Fullscreen)
+            return new Size(positionRect.Width, positionRect.Height);
+
+        Size nonContentSize = GetGrabFrameNonContentSize();
+        double contentWidth = positionRect.Width - nonContentSize.Width;
+        double contentHeight = positionRect.Height - nonContentSize.Height;
+
+        if (!double.IsFinite(contentWidth) || contentWidth <= 0)
+            contentWidth = positionRect.Width;
+
+        if (!double.IsFinite(contentHeight) || contentHeight <= 0)
+            contentHeight = positionRect.Height;
+
+        return new Size(contentWidth, contentHeight);
+    }
+
+    /// <summary>
+    /// Returns the physical-pixel screen rectangle that exactly covers the
+    /// transparent content area (RectanglesBorder, Row 1 of the grid).
+    /// Uses PointToScreen so it is always accurate regardless of border
+    /// thickness, DPI, or future layout changes.
+    /// </summary>
+    internal System.Drawing.Rectangle GetContentAreaScreenRect()
+    {
+        DpiScale dpi = VisualTreeHelper.GetDpi(this);
+        Point topLeft = RectanglesBorder.PointToScreen(new Point(0, 0));
+        return new System.Drawing.Rectangle(
+            (int)topLeft.X,
+            (int)topLeft.Y,
+            (int)(RectanglesBorder.ActualWidth * dpi.DpiScaleX),
+            (int)(RectanglesBorder.ActualHeight * dpi.DpiScaleY));
     }
 
     public Rect GetImageContentRect()
@@ -213,17 +446,21 @@ public Rect GetImageContentRect()
         // This is a WIP to try to remove the gray letterboxes on either
         // side of the image when zooming it.
 
-        Rect imageRect = Rect.Empty;
+        if (frameContentImageSource is null || !IsLoaded || !RectanglesCanvas.IsLoaded)
+            return Rect.Empty;
 
-        if (frameContentImageSource is null)
-            return imageRect;
+        Rect canvasPlacement = RectanglesCanvas.GetAbsolutePlacement(true);
+        if (canvasPlacement == Rect.Empty)
+            return Rect.Empty;
 
-        imageRect = RectanglesCanvas.GetAbsolutePlacement(true);
         Size rectCanvasSize = RectanglesCanvas.RenderSize;
-        imageRect.Width = rectCanvasSize.Width;
-        imageRect.Height = rectCanvasSize.Height;
+        if (!double.IsFinite(rectCanvasSize.Width) || !double.IsFinite(rectCanvasSize.Height)
+            || rectCanvasSize.Width <= 0 || rectCanvasSize.Height <= 0)
+        {
+            return canvasPlacement;
+        }
 
-        return imageRect;
+        return new Rect(canvasPlacement.X, canvasPlacement.Y, rectCanvasSize.Width, rectCanvasSize.Height);
     }
 
     private void StandardInitialize()
@@ -993,33 +1230,15 @@ private async Task DrawRectanglesAroundWords(string searchWord = "")
         RectanglesCanvas.Children.Clear();
         wordBorders.Clear();
 
-        Point windowPosition = this.GetAbsolutePosition();
         DpiScale dpi = VisualTreeHelper.GetDpi(this);
-        double canvasScale = CanvasViewBox.GetHorizontalScaleFactor();
-        Point rectanglesPosition = RectanglesCanvas.TransformToAncestor(this)
-                                                   .Transform(new Point(0, 0));
-
-        if (double.IsNaN(canvasScale))
-            canvasScale = 1;
-
-        double ContentWidth = RectanglesCanvas.RenderSize.Width;
-        double ContentHeight = RectanglesCanvas.RenderSize.Height;
-
-        if (ContentWidth == 4 || ContentHeight == 2)
+        System.Drawing.Rectangle rectCanvasSize = GetContentAreaScreenRect();
+        if (rectCanvasSize.Width <= 0 || rectCanvasSize.Height <= 0)
         {
-            ContentWidth = RectanglesBorder.RenderSize.Width;
-            ContentHeight = RectanglesBorder.RenderSize.Height;
-            rectanglesPosition = new(-2, 32);
+            isDrawing = false;
+            reDrawTimer.Start();
+            return;
         }
 
-        System.Drawing.Rectangle rectCanvasSize = new()
-        {
-            Width = (int)(ContentWidth * dpi.DpiScaleX * canvasScale),
-            Height = (int)(ContentHeight * dpi.DpiScaleY * canvasScale),
-            X = (int)((windowPosition.X + rectanglesPosition.X) * dpi.DpiScaleX),
-            Y = (int)((windowPosition.Y + rectanglesPosition.Y) * dpi.DpiScaleY)
-        };
-
         if (ocrResultOfWindow is null || ocrResultOfWindow.Lines.Length == 0)
         {
             ILanguage lang = CurrentLanguage ?? LanguageUtilities.GetCurrentInputLanguage();
@@ -1031,13 +1250,22 @@ private async Task DrawRectanglesAroundWords(string searchWord = "")
 
         isSpaceJoining = CurrentLanguage!.IsSpaceJoining();
 
-        System.Drawing.Bitmap? bmp = null;
+        System.Drawing.Bitmap? bmp = Singleton<HistoryService>.Instance.CachedBitmap;
+        bool shouldDisposeBmp = false;
 
-        if (frameContentImageSource is BitmapSource bmpImg)
+        if (bmp is null && frameContentImageSource is BitmapSource bmpImg)
+        {
             bmp = ImageMethods.BitmapSourceToBitmap(bmpImg);
+            shouldDisposeBmp = true;
+        }
 
         int lineNumber = 0;
         double viewBoxZoomFactor = CanvasViewBox.GetHorizontalScaleFactor();
+        if (!double.IsFinite(viewBoxZoomFactor) || viewBoxZoomFactor <= 0 || viewBoxZoomFactor > 4)
+            viewBoxZoomFactor = 1;
+        Point canvasOriginInBorder = RectanglesCanvas.TranslatePoint(new Point(0, 0), RectanglesBorder);
+        double borderToCanvasX = -canvasOriginInBorder.X;
+        double borderToCanvasY = -canvasOriginInBorder.Y;
 
         foreach (IOcrLine ocrLine in ocrResultOfWindow.Lines)
         {
@@ -1050,7 +1278,7 @@ private async Task DrawRectanglesAroundWords(string searchWord = "")
             SolidColorBrush backgroundBrush = new(Colors.Black);
 
             if (bmp is not null)
-                backgroundBrush = GetBackgroundBrushFromBitmap(ref dpi, windowFrameImageScale, bmp, ref lineRect);
+                backgroundBrush = GetBackgroundBrushFromOcrBitmap(windowFrameImageScale, bmp, ref lineRect);
 
             string ocrText = lineText.ToString();
 
@@ -1064,8 +1292,8 @@ private async Task DrawRectanglesAroundWords(string searchWord = "")
             {
                 Width = ((lineRect.Width / (dpi.DpiScaleX * windowFrameImageScale)) + 2) / viewBoxZoomFactor,
                 Height = ((lineRect.Height / (dpi.DpiScaleY * windowFrameImageScale)) + 2) / viewBoxZoomFactor,
-                Top = (lineRect.Y / (dpi.DpiScaleY * windowFrameImageScale) - 1) / viewBoxZoomFactor,
-                Left = (lineRect.X / (dpi.DpiScaleX * windowFrameImageScale) - 1) / viewBoxZoomFactor,
+                Top = ((lineRect.Y / (dpi.DpiScaleY * windowFrameImageScale) - 1) + borderToCanvasY) / viewBoxZoomFactor,
+                Left = ((lineRect.X / (dpi.DpiScaleX * windowFrameImageScale) - 1) + borderToCanvasX) / viewBoxZoomFactor,
                 Word = ocrText,
                 OwnerGrabFrame = this,
                 LineNumber = lineNumber,
@@ -1108,7 +1336,8 @@ private async Task DrawRectanglesAroundWords(string searchWord = "")
 
         isDrawing = false;
 
-        bmp?.Dispose();
+        if (shouldDisposeBmp)
+            bmp?.Dispose();
         reSearchTimer.Start();
 
         // Trigger translation if enabled
@@ -1240,6 +1469,8 @@ private void FreezeGrabFrame()
             GrabFrameImage.Source = frameContentImageSource;
         }
 
+        SyncRectanglesCanvasSizeToImage();
+
         FreezeToggleButton.IsChecked = true;
         Topmost = false;
         Background = new SolidColorBrush(Colors.DimGray);
@@ -1247,6 +1478,33 @@ private void FreezeGrabFrame()
         IsFreezeMode = true;
     }
 
+    private void SyncRectanglesCanvasSizeToImage()
+    {
+        if (GrabFrameImage.Source is not BitmapSource source)
+            return;
+
+        // Convert physical pixels to WPF device-independent pixels so the canvas
+        // coordinate space stays consistent with DrawRectanglesAroundWords, which
+        // divides OCR pixel coordinates by dpi.DpiScaleX/Y to produce DIP positions.
+        // Using raw PixelWidth would cause the Viewbox to scale down at DPI > 100%,
+        // shifting viewBoxZoomFactor and borderToCanvasX/Y, and misplacing word borders.
+        DpiScale dpi = VisualTreeHelper.GetDpi(this);
+        double sourceWidth = source.PixelWidth > 0 ? source.PixelWidth / dpi.DpiScaleX : source.Width;
+        double sourceHeight = source.PixelHeight > 0 ? source.PixelHeight / dpi.DpiScaleY : source.Height;
+
+        if (double.IsFinite(sourceWidth) && sourceWidth > 0)
+        {
+            GrabFrameImage.Width = sourceWidth;
+            RectanglesCanvas.Width = sourceWidth;
+        }
+
+        if (double.IsFinite(sourceHeight) && sourceHeight > 0)
+        {
+            GrabFrameImage.Height = sourceHeight;
+            RectanglesCanvas.Height = sourceHeight;
+        }
+    }
+
     private async void FreezeMI_Click(object sender, RoutedEventArgs e)
     {
         if (IsFreezeMode)
@@ -1276,6 +1534,54 @@ private void FreezeToggleButton_Click(object? sender = null, RoutedEventArgs? e
             UnfreezeGrabFrame();
     }
 
+    private static SolidColorBrush GetBackgroundBrushFromOcrBitmap(double scale, System.Drawing.Bitmap bmp, ref Windows.Foundation.Rect lineRect)
+    {
+        if (!double.IsFinite(scale) || scale <= 0)
+            scale = 1;
+
+        double boxLeft = lineRect.Left / scale;
+        double boxTop = lineRect.Top / scale;
+        double boxRight = lineRect.Right / scale;
+        double boxBottom = lineRect.Bottom / scale;
+        double boxWidth = Math.Max(0, boxRight - boxLeft);
+        double boxHeight = Math.Max(0, boxBottom - boxTop);
+        double insetX = Math.Min(boxWidth / 2, Math.Max(1, boxWidth * 0.12));
+        double insetY = Math.Min(boxHeight / 2, Math.Max(1, boxHeight * 0.12));
+
+        int pxLeft = Math.Clamp((int)(boxLeft + insetX), 0, bmp.Width - 1);
+        int pxTop = Math.Clamp((int)(boxTop + insetY), 0, bmp.Height - 1);
+        int pxRight = Math.Clamp((int)(boxRight - insetX), 0, bmp.Width - 1);
+        int pxBottom = Math.Clamp((int)(boxBottom - insetY), 0, bmp.Height - 1);
+
+        if (pxRight < pxLeft)
+            pxRight = pxLeft;
+
+        if (pxBottom < pxTop)
+            pxBottom = pxTop;
+
+        System.Drawing.Color pxColorLeftTop = bmp.GetPixel(pxLeft, pxTop);
+        System.Drawing.Color pxColorRightTop = bmp.GetPixel(pxRight, pxTop);
+        System.Drawing.Color pxColorRightBottom = bmp.GetPixel(pxRight, pxBottom);
+        System.Drawing.Color pxColorLeftBottom = bmp.GetPixel(pxLeft, pxBottom);
+
+        List<Color> mediaColorList =
+        [
+            ColorHelper.MediaColorFromDrawingColor(pxColorLeftTop),
+            ColorHelper.MediaColorFromDrawingColor(pxColorRightTop),
+            ColorHelper.MediaColorFromDrawingColor(pxColorRightBottom),
+            ColorHelper.MediaColorFromDrawingColor(pxColorLeftBottom),
+        ];
+
+        Color? mostCommonColor = mediaColorList.GroupBy(c => c)
+                                               .OrderBy(g => g.Count())
+                                               .LastOrDefault()?.Key;
+
+        if (mostCommonColor is not null)
+            return new SolidColorBrush(mostCommonColor.Value);
+
+        return ColorHelper.SolidColorBrushFromDrawingColor(pxColorLeftTop);
+    }
+
     private SolidColorBrush GetBackgroundBrushFromBitmap(ref DpiScale dpi, double scale, System.Drawing.Bitmap bmp, ref Windows.Foundation.Rect lineRect)
     {
         SolidColorBrush backgroundBrush = new(Colors.Black);
@@ -1290,10 +1596,26 @@ private SolidColorBrush GetBackgroundBrushFromBitmap(ref DpiScale dpi, double sc
         double rightFraction = boxRight / RectanglesCanvas.ActualWidth;
         double bottomFraction = boxBottom / RectanglesCanvas.ActualHeight;
 
-        int pxLeft = Math.Clamp((int)(leftFraction * bmp.Width) - 1, 0, bmp.Width - 1);
-        int pxTop = Math.Clamp((int)(topFraction * bmp.Height) - 2, 0, bmp.Height - 1);
-        int pxRight = Math.Clamp((int)(rightFraction * bmp.Width) + 1, 0, bmp.Width - 1);
-        int pxBottom = Math.Clamp((int)(bottomFraction * bmp.Height) + 1, 0, bmp.Height - 1);
+        int rawLeft = Math.Clamp((int)(leftFraction * bmp.Width), 0, bmp.Width - 1);
+        int rawTop = Math.Clamp((int)(topFraction * bmp.Height), 0, bmp.Height - 1);
+        int rawRight = Math.Clamp((int)(rightFraction * bmp.Width), 0, bmp.Width - 1);
+        int rawBottom = Math.Clamp((int)(bottomFraction * bmp.Height), 0, bmp.Height - 1);
+
+        int spanX = Math.Max(0, rawRight - rawLeft);
+        int spanY = Math.Max(0, rawBottom - rawTop);
+        int insetX = Math.Min(spanX / 2, Math.Max(1, spanX / 8));
+        int insetY = Math.Min(spanY / 2, Math.Max(1, spanY / 8));
+        int pxLeft = Math.Clamp(rawLeft + insetX, 0, bmp.Width - 1);
+        int pxTop = Math.Clamp(rawTop + insetY, 0, bmp.Height - 1);
+        int pxRight = Math.Clamp(rawRight - insetX, 0, bmp.Width - 1);
+        int pxBottom = Math.Clamp(rawBottom - insetY, 0, bmp.Height - 1);
+
+        if (pxRight < pxLeft)
+            pxRight = pxLeft;
+
+        if (pxBottom < pxTop)
+            pxBottom = pxTop;
+
         System.Drawing.Color pxColorLeftTop = bmp.GetPixel(pxLeft, pxTop);
         System.Drawing.Color pxColorRightTop = bmp.GetPixel(pxRight, pxTop);
         System.Drawing.Color pxColorRightBottom = bmp.GetPixel(pxRight, pxBottom);
@@ -1435,7 +1757,7 @@ private bool HandleCtrlCombo(Key key)
 
     private void HandleDelete(object? sender = null, RoutedEventArgs? e = null)
     {
-        if (SearchBox.IsFocused)
+        if (Keyboard.FocusedElement is TextBox)
             return;
 
         UndoRedo.StartTransaction();
@@ -1923,6 +2245,12 @@ private async void ReDrawTimer_Tick(object? sender, EventArgs? e)
         reDrawTimer.Stop();
         SetRefreshOrOcrFrameBtnVis();
 
+        if (!IsLoaded || RectanglesBorder.ActualWidth <= 1 || RectanglesBorder.ActualHeight <= 1)
+        {
+            reDrawTimer.Start();
+            return;
+        }
+
         if (CheckKey(VirtualKeyCodes.LeftButton) || CheckKey(VirtualKeyCodes.MiddleButton))
         {
             reDrawTimer.Start();
@@ -2071,6 +2399,9 @@ private void ReSearchTimer_Tick(object? sender, EventArgs e)
             MatchesTXTBLK.Text = $"{numberOfMatches} Matches";
         MatchesMenu.Visibility = Visibility.Visible;
         LanguagesComboBox.Visibility = Visibility.Collapsed;
+
+        if (SaveAsTemplateBTN.IsChecked == true)
+            UpdateTemplateBadges();
     }
 
     private void ResetGrabFrame()
@@ -2079,6 +2410,10 @@ private void ResetGrabFrame()
 
         MainZoomBorder.Reset();
         RectanglesCanvas.RenderTransform = Transform.Identity;
+        RectanglesCanvas.ClearValue(WidthProperty);
+        RectanglesCanvas.ClearValue(HeightProperty);
+        GrabFrameImage.ClearValue(WidthProperty);
+        GrabFrameImage.ClearValue(HeightProperty);
         IsOcrValid = false;
         ocrResultOfWindow = null;
 
@@ -2178,6 +2513,284 @@ private void SettingsBTN_Click(object sender, RoutedEventArgs e)
         WindowUtilities.OpenOrActivateWindow<SettingsWindow>();
     }
 
+    private void ManageGrabTemplates_Click(object sender, RoutedEventArgs e)
+    {
+        PostGrabActionEditor editor = new();
+        editor.Show();
+    }
+
+    private void SaveAsTemplate_Click(object sender, RoutedEventArgs e)
+    {
+        bool show = SaveAsTemplateBTN.IsChecked == true;
+        TemplateSavePanel.Visibility = show ? Visibility.Visible : Visibility.Collapsed;
+        if (show)
+        {
+            if (!IsFreezeMode)
+            {
+                FreezeToggleButton.IsChecked = true;
+                FreezeGrabFrame();
+            }
+            TemplateNameBox.Focus();
+        }
+
+        UpdateTemplateBadges();
+    }
+
+    private void SaveTemplateSave_Click(object sender, RoutedEventArgs e)
+    {
+        string name = TemplateNameBox.Text.Trim();
+        if (string.IsNullOrWhiteSpace(name))
+        {
+            TemplateNameBox.Focus();
+            return;
+        }
+
+        string outputTemplateText = TemplateOutputBox.GetSerializedText();
+
+        // Parse pattern references from the output template
+        List<TemplatePatternMatch> patternMatches = ParsePatternMatchesFromTemplate(outputTemplateText);
+
+        if (wordBorders.Count == 0 && patternMatches.Count == 0)
+        {
+            MessageBox.Show(
+                "Use Ctrl+drag to draw at least one region, or add a pattern placeholder, before saving.",
+                "No Regions or Patterns",
+                MessageBoxButton.OK,
+                MessageBoxImage.Information);
+            return;
+        }
+
+        double cw = RectanglesCanvas.ActualWidth;
+        double ch = RectanglesCanvas.ActualHeight;
+
+        // Sort regions in reading order: top-to-bottom, then left-to-right
+        List<WordBorder> sorted = [.. wordBorders.OrderBy(w => w.Top).ThenBy(w => w.Left)];
+
+        List<TemplateRegion> regions = [.. sorted.Select((wb, i) => new TemplateRegion
+        {
+            RegionNumber = i + 1,
+            Label = string.IsNullOrWhiteSpace(wb.Word) ? $"Region {i + 1}" : wb.Word,
+            RatioLeft = wb.Left / cw,
+            RatioTop = wb.Top / ch,
+            RatioWidth = wb.ActualWidth / cw,
+            RatioHeight = wb.ActualHeight / ch,
+        })];
+
+        GrabTemplate template = new(name)
+        {
+            OutputTemplate = outputTemplateText,
+            ReferenceImageWidth = cw,
+            ReferenceImageHeight = ch,
+            Regions = regions,
+            PatternMatches = patternMatches,
+        };
+
+        if (_editingTemplate is not null)
+        {
+            template.Id = _editingTemplate.Id;
+            template.CreatedDate = _editingTemplate.CreatedDate;
+        }
+
+        template.SourceImagePath = GrabTemplateManager.SaveTemplateReferenceImage(frameContentImageSource as BitmapSource, name, template.Id)
+            ?? _currentImagePath
+            ?? _editingTemplate?.SourceImagePath
+            ?? string.Empty;
+
+        GrabTemplateManager.AddOrUpdateTemplate(template);
+
+        SaveAsTemplateBTN.IsChecked = false;
+        TemplateSavePanel.Visibility = Visibility.Collapsed;
+        TemplateNameBox.Text = string.Empty;
+        TemplateOutputBox.SetSerializedText(string.Empty);
+        UpdateTemplateBadges();
+
+        int totalItems = regions.Count + patternMatches.Count;
+        string itemsDesc = regions.Count > 0 && patternMatches.Count > 0
+            ? $"{regions.Count} region(s) and {patternMatches.Count} pattern(s)"
+            : regions.Count > 0
+                ? $"{regions.Count} region(s)"
+                : $"{patternMatches.Count} pattern(s)";
+
+        MessageBox.Show(
+            $"Template \"{name}\" saved with {itemsDesc}.\n\nEnable it in Post-Grab Actions Settings to use it during a Fullscreen Grab.",
+            "Template Saved",
+            MessageBoxButton.OK,
+            MessageBoxImage.Information);
+    }
+
+    /// <summary>
+    /// Parses {p:Name:mode} and {p:Name:mode:separator} placeholders from the output template
+    /// and builds TemplatePatternMatch objects by resolving against saved patterns.
+    /// </summary>
+    private static List<TemplatePatternMatch> ParsePatternMatchesFromTemplate(string outputTemplate)
+    {
+        if (string.IsNullOrEmpty(outputTemplate))
+            return [];
+
+        MatchCollection matches = TemplatePattern().Matches(outputTemplate);
+        Dictionary<string, TemplatePatternMatch> uniquePatterns = new(StringComparer.OrdinalIgnoreCase);
+
+        // Load saved patterns for ID resolution
+        StoredRegex[] savedPatterns;
+        try
+        {
+            string json = Settings.Default.RegexList;
+            savedPatterns = string.IsNullOrWhiteSpace(json)
+                ? StoredRegex.GetDefaultPatterns()
+                : JsonSerializer.Deserialize<StoredRegex[]>(json) ?? StoredRegex.GetDefaultPatterns();
+        }
+        catch
+        {
+            savedPatterns = StoredRegex.GetDefaultPatterns();
+        }
+
+        foreach (Match match in matches)
+        {
+            string patternName = match.Groups[1].Value;
+            string mode = match.Groups[2].Value;
+            string separator = match.Groups[3].Success ? match.Groups[3].Value : ", ";
+
+            if (uniquePatterns.ContainsKey(patternName))
+                continue;
+
+            StoredRegex? stored = savedPatterns.FirstOrDefault(
+                p => p.Name.Equals(patternName, StringComparison.OrdinalIgnoreCase));
+
+            uniquePatterns[patternName] = new TemplatePatternMatch(
+                patternId: stored?.Id ?? string.Empty,
+                patternName: patternName,
+                matchMode: mode,
+                separator: separator);
+        }
+
+        return [.. uniquePatterns.Values];
+    }
+
+    private void SaveTemplateCancel_Click(object sender, RoutedEventArgs e)
+    {
+        SaveAsTemplateBTN.IsChecked = false;
+        TemplateSavePanel.Visibility = Visibility.Collapsed;
+        UpdateTemplateBadges();
+    }
+
+    private void UpdateTemplateBadges()
+    {
+        bool isTemplateMode = SaveAsTemplateBTN.IsChecked == true;
+
+        if (!isTemplateMode)
+        {
+            foreach (WordBorder wb in wordBorders)
+            {
+                wb.TemplateIndex = 0;
+                wb.Opacity = 1.0;
+                wb.SetHighlightedForOutput(false);
+            }
+            return;
+        }
+
+        List<WordBorder> sorted = [.. wordBorders.OrderBy(w => w.Top).ThenBy(w => w.Left)];
+        for (int i = 0; i < sorted.Count; i++)
+            sorted[i].TemplateIndex = i + 1;
+
+        UpdateTemplatePickerItems();
+        UpdateTemplateRegionOpacities();
+    }
+
+    private void UpdateTemplateRegionOpacities()
+    {
+        if (SaveAsTemplateBTN.IsChecked != true)
+            return;
+
+        string outputTemplate = TemplateOutputBox.GetSerializedText();
+        HashSet<int> referenced = [.. OutputTemplateReferenced().Matches(outputTemplate)
+            .Select(m => int.TryParse(m.Groups[1].Value, out int n) ? n : 0)
+            .Where(n => n > 0)];
+
+        foreach (WordBorder wb in wordBorders)
+        {
+            bool isReferenced = referenced.Count == 0 || referenced.Contains(wb.TemplateIndex);
+            wb.Opacity = 1.0;
+            wb.SetHighlightedForOutput(isReferenced);
+        }
+    }
+
+    private void TemplateOutputBox_TextChanged(object sender, TextChangedEventArgs e)
+    {
+        UpdateTemplateRegionOpacities();
+    }
+
+    private void UpdateTemplatePickerItems()
+    {
+        List<WordBorder> sorted = [.. wordBorders.OrderBy(w => w.Top).ThenBy(w => w.Left)];
+
+        // Region items
+        List<InlinePickerItem> items = [.. sorted
+            .Select((wb, i) =>
+            {
+                string label = string.IsNullOrWhiteSpace(wb.Word) ? $"Region {i + 1}" : wb.Word;
+                return new InlinePickerItem(label, $"{{{i + 1}}}", "Regions");
+            })];
+
+        // Pattern items from saved StoredRegex patterns
+        List<InlinePickerItem> patternItems = LoadPatternPickerItems();
+        items.AddRange(patternItems);
+
+        TemplateOutputBox.ItemsSource = items;
+
+        // Wire up the pattern selection callback
+        TemplateOutputBox.PatternItemSelected ??= OnPatternItemSelected;
+    }
+
+    private static List<InlinePickerItem> LoadPatternPickerItems()
+    {
+        StoredRegex[] patterns;
+        try
+        {
+            string json = Settings.Default.RegexList;
+            patterns = string.IsNullOrWhiteSpace(json)
+                ? StoredRegex.GetDefaultPatterns()
+                : JsonSerializer.Deserialize<StoredRegex[]>(json) ?? StoredRegex.GetDefaultPatterns();
+        }
+        catch
+        {
+            patterns = StoredRegex.GetDefaultPatterns();
+        }
+
+        return [.. patterns.Select(p =>
+            new InlinePickerItem(p.Name, $"{{p:{p.Name}:first}}", "Patterns"))];
+    }
+
+    private TemplatePatternMatch? OnPatternItemSelected(InlinePickerItem item)
+    {
+        // Extract pattern ID by looking up the name
+        StoredRegex[] patterns;
+        try
+        {
+            string json = Settings.Default.RegexList;
+            patterns = string.IsNullOrWhiteSpace(json)
+                ? StoredRegex.GetDefaultPatterns()
+                : JsonSerializer.Deserialize<StoredRegex[]>(json) ?? StoredRegex.GetDefaultPatterns();
+        }
+        catch
+        {
+            patterns = StoredRegex.GetDefaultPatterns();
+        }
+
+        StoredRegex? storedRegex = patterns.FirstOrDefault(
+            p => p.Name.Equals(item.DisplayName, StringComparison.OrdinalIgnoreCase));
+
+        string patternId = storedRegex?.Id ?? string.Empty;
+        string patternName = item.DisplayName;
+
+        PatternMatchModeDialog dialog = new(patternId, patternName)
+        {
+            Owner = this,
+        };
+
+        bool? dialogResult = dialog.ShowDialog();
+        return dialogResult == true ? dialog.Result : null;
+    }
+
     private void TableToggleButton_Click(object? sender = null, RoutedEventArgs? e = null)
     {
         RemoveTableLines();
@@ -2194,11 +2807,13 @@ private async Task TryLoadImageFromPath(string path)
             BitmapImage droppedImage = new();
             droppedImage.BeginInit();
             droppedImage.UriSource = fileURI;
+            droppedImage.CacheOption = BitmapCacheOption.OnLoad; // decode fully into memory and release the file handle
             System.Drawing.RotateFlipType rotateFlipType = ImageMethods.GetRotateFlipType(path);
             ImageMethods.RotateImage(droppedImage, rotateFlipType);
             droppedImage.EndInit();
             frameContentImageSource = droppedImage;
             hasLoadedImageSource = true;
+            _currentImagePath = path;
             FreezeToggleButton.IsChecked = true;
             FreezeGrabFrame();
             FreezeToggleButton.Visibility = Visibility.Collapsed;
@@ -2414,7 +3029,7 @@ private void Window_PreviewKeyDown(object sender, KeyEventArgs e)
         if (IsCtrlDown)
             RectanglesCanvas.Cursor = Cursors.Cross;
 
-        if (IsEditingAnyWordBorders || SearchBox.IsFocused)
+        if (IsEditingAnyWordBorders || Keyboard.FocusedElement is TextBox or RichTextBox)
             return;
 
         if (e.Key == Key.Delete)
@@ -3112,5 +3727,10 @@ private void CancelTranslationButton_Click(object sender, RoutedEventArgs e)
         UpdateFrameText();
     }
 
+    [GeneratedRegex(@"\{p:([^:}]+):([^:}]+)(?::([^}]*))?\}")]
+    private static partial Regex TemplatePattern();
+    [GeneratedRegex(@"\{(\d+)(?::[a-z]+)?\}")]
+    private static partial Regex OutputTemplateReferenced();
+
     #endregion Methods
 }
diff --git a/Text-Grab/Views/QuickSimpleLookup.xaml.cs b/Text-Grab/Views/QuickSimpleLookup.xaml.cs
index 8152f8d0..936e83f2 100644
--- a/Text-Grab/Views/QuickSimpleLookup.xaml.cs
+++ b/Text-Grab/Views/QuickSimpleLookup.xaml.cs
@@ -468,6 +468,19 @@ private async void PutValueIntoClipboard(KeyboardModifiersDown? keysDown = null)
                 }
                 break;
             case KeyboardModifiersDown.Ctrl:
+                if (selectedLookupItems.FirstOrDefault() is LookupItem ctrlItem
+                    && ctrlItem.Kind == LookupItemKind.GrabTemplate
+                    && ctrlItem.TemplateId is not null)
+                {
+                    GrabTemplate? ctrlTemplate = GrabTemplateManager.GetTemplateById(ctrlItem.TemplateId);
+                    if (ctrlTemplate is not null)
+                    {
+                        GrabFrame editFrame = new(ctrlTemplate);
+                        editFrame.Show();
+                    }
+                    openedHistoryItemOrLink = true;
+                    break;
+                }
                 foreach (LookupItem lItem in selectedLookupItems)
                     stringBuilder.AppendLine(lItem.ShortValue);
                 break;
@@ -508,6 +521,13 @@ private async void PutValueIntoClipboard(KeyboardModifiersDown? keysDown = null)
                         case LookupItemKind.Command:
                             openedHistoryItemOrLink = await RunCli(lItem.LongValue);
                             break;
+                        case LookupItemKind.GrabTemplate when lItem.TemplateId is not null:
+                            {
+                                this.Hide();
+                                WindowUtilities.LaunchFullScreenGrab(null, lItem.TemplateId);
+                                openedHistoryItemOrLink = true;
+                                break;
+                            }
                         case LookupItemKind.Dynamic:
                             break;
                         default:
@@ -712,6 +732,7 @@ private async Task LoadDataGridContent(string csvToOpenPath)
             PopulateSampleData();
 
         MainDataGrid.ItemsSource = null;
+        ItemsDictionary.Clear();
 
         ItemsDictionary.AddRange(ParseStringToRows(contentToParse, true));
         lookupItems = [.. ItemsDictionary];
@@ -722,6 +743,8 @@ private async Task LoadDataGridContent(string csvToOpenPath)
             SearchHistory.IsChecked = true;
         }
 
+        AddGrabTemplatesToItemsDictionary();
+
         MainDataGrid.ItemsSource = ItemsDictionary;
 
         UpdateRowCount();
@@ -954,6 +977,21 @@ private void AddHistoryItemsToItemsDictionary()
         }
     }
 
+    private void AddGrabTemplatesToItemsDictionary()
+    {
+        List<GrabTemplate> templates = GrabTemplateManager.GetAllTemplates();
+
+        foreach (GrabTemplate template in templates)
+        {
+            LookupItem item = new(template.Name, template.OutputTemplate)
+            {
+                Kind = LookupItemKind.GrabTemplate,
+                TemplateId = template.Id,
+            };
+            ItemsDictionary.Add(item);
+        }
+    }
+
     private async Task WriteDataToCSV()
     {
         if (!string.IsNullOrWhiteSpace(SearchBox.Text))