From da044ecba523cb5c84fda4a98832c1df245494e4 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Sun, 1 Mar 2026 11:24:49 -0600
Subject: [PATCH 01/35] Add template-based capture system with region support

Introduce GrabTemplate, TemplateRegion, and PostGrabContext classes to enable reusable OCR templates for fixed-layout documents. Templates define named, numbered regions and an output format for assembling OCR results. PostGrabContext encapsulates all data from a grab action, supporting both simple and template-based post-processing. This lays the foundation for structured data extraction and advanced OCR workflows.
---
 Text-Grab/Models/GrabTemplate.cs    | 96 +++++++++++++++++++++++++++++
 Text-Grab/Models/PostGrabContext.cs | 36 +++++++++++
 Text-Grab/Models/TemplateRegion.cs  | 66 ++++++++++++++++++++
 3 files changed, 198 insertions(+)
 create mode 100644 Text-Grab/Models/GrabTemplate.cs
 create mode 100644 Text-Grab/Models/PostGrabContext.cs
 create mode 100644 Text-Grab/Models/TemplateRegion.cs

diff --git a/Text-Grab/Models/GrabTemplate.cs b/Text-Grab/Models/GrabTemplate.cs
new file mode 100644
index 00000000..e21ed33a
--- /dev/null
+++ b/Text-Grab/Models/GrabTemplate.cs
@@ -0,0 +1,96 @@
+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:
+///   {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
+///   \n           — newline
+///   \t           — tab
+///   \\           — literal backslash
+///   \{           — literal opening brace
+/// </summary>
+public 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}, \n, \t.
+    /// Example: "Name: {1}\nEmail: {2}\nPhone: {3}"
+    /// </summary>
+    public string OutputTemplate { get; set; } = string.Empty;
+
+    public GrabTemplate() { }
+
+    public GrabTemplate(string name)
+    {
+        Name = name;
+    }
+
+    /// <summary>
+    /// Returns whether this template has the minimum required data to be executed.
+    /// </summary>
+    public bool IsValid =>
+        !string.IsNullOrWhiteSpace(Name)
+        && Regions.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 =
+            System.Text.RegularExpressions.Regex.Matches(
+                OutputTemplate,
+                @"\{(\d+)(?::[a-z]+)?\}");
+
+        foreach (System.Text.RegularExpressions.Match match in matches)
+        {
+            if (int.TryParse(match.Groups[1].Value, out int number))
+                yield return number;
+        }
+    }
+}
diff --git a/Text-Grab/Models/PostGrabContext.cs b/Text-Grab/Models/PostGrabContext.cs
new file mode 100644
index 00000000..63707a09
--- /dev/null
+++ b/Text-Grab/Models/PostGrabContext.cs
@@ -0,0 +1,36 @@
+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>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);
+}
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,
+        };
+    }
+}

From 2dc268c5ea6db7e26528e955867beea2f03701b1 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Sun, 1 Mar 2026 11:25:54 -0600
Subject: [PATCH 02/35] Add file-based GrabTemplate storage and executor

Replaces settings-based template storage with a robust file-based system (GrabTemplateManager) supporting CRUD, migration, and error handling. Implements GrabTemplateExecutor for OCR region extraction and flexible output template formatting with modifiers and escapes. Includes comprehensive unit tests for both manager and executor.
---
 Tests/GrabTemplateExecutorTests.cs          | 146 +++++++++++++
 Tests/GrabTemplateManagerTests.cs           | 230 ++++++++++++++++++++
 Text-Grab/Utilities/GrabTemplateExecutor.cs | 186 ++++++++++++++++
 Text-Grab/Utilities/GrabTemplateManager.cs  | 227 +++++++++++++++++++
 4 files changed, 789 insertions(+)
 create mode 100644 Tests/GrabTemplateExecutorTests.cs
 create mode 100644 Tests/GrabTemplateManagerTests.cs
 create mode 100644 Text-Grab/Utilities/GrabTemplateExecutor.cs
 create mode 100644 Text-Grab/Utilities/GrabTemplateManager.cs

diff --git a/Tests/GrabTemplateExecutorTests.cs b/Tests/GrabTemplateExecutorTests.cs
new file mode 100644
index 00000000..94f00754
--- /dev/null
+++ b/Tests/GrabTemplateExecutorTests.cs
@@ -0,0 +1,146 @@
+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);
+    }
+}
diff --git a/Tests/GrabTemplateManagerTests.cs b/Tests/GrabTemplateManagerTests.cs
new file mode 100644
index 00000000..e99d92fd
--- /dev/null
+++ b/Tests/GrabTemplateManagerTests.cs
@@ -0,0 +1,230 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+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/Text-Grab/Utilities/GrabTemplateExecutor.cs b/Text-Grab/Utilities/GrabTemplateExecutor.cs
new file mode 100644
index 00000000..e3d3add4
--- /dev/null
+++ b/Text-Grab/Utilities/GrabTemplateExecutor.cs
@@ -0,0 +1,186 @@
+using System;
+using System.Collections.Generic;
+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:
+///   {N}        — OCR text from region N  (1-based)
+///   {N:trim}   — trimmed OCR text
+///   {N:upper}  — uppercased OCR text
+///   {N:lower}  — lowercased OCR text
+///   \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);
+
+    // ── 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 WPF units, pre-DPI-scaling applied by caller)
+    ///     that bounds the user's selection. Template region ratios are applied to
+    ///     this rectangle's width/height.
+    /// </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;
+
+        // 1. OCR each region
+        ILanguage resolvedLanguage = language ?? LanguageUtilities.GetOCRLanguage();
+        Dictionary<int, string> regionResults = await OcrAllRegionsAsync(
+            template, captureRegion, resolvedLanguage);
+
+        // 2. Apply output template
+        return ApplyOutputTemplate(template.OutputTemplate, regionResults);
+    }
+
+    /// <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;
+    }
+
+    // ── 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)
+    {
+        List<string> issues = [];
+        HashSet<int> available = [.. availableRegionNumbers];
+
+        MatchCollection matches = PlaceholderRegex.Matches(outputTemplate);
+        HashSet<int> referenced = [];
+
+        foreach (Match match in matches)
+        {
+            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.");
+        }
+
+        return issues;
+    }
+}
diff --git a/Text-Grab/Utilities/GrabTemplateManager.cs b/Text-Grab/Utilities/GrabTemplateManager.cs
new file mode 100644
index 00000000..6f01f9f2
--- /dev/null
+++ b/Text-Grab/Utilities/GrabTemplateManager.cs
@@ -0,0 +1,227 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+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);
+    }
+
+    // ── 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);
+    }
+}

From ae3aa3da7a618a6ce0bf8765e282a96228aad3f9 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Sun, 1 Mar 2026 11:28:57 -0600
Subject: [PATCH 03/35] Add Grab Template support as post-grab actions

- Add TemplateId property to ButtonInfo for template actions
- Include Grab Templates in available post-grab actions
- Add ApplyTemplate_Click action handling in PostGrabActionManager
- Overload ExecutePostGrabAction to accept PostGrabContext
- Improve BarcodeUtilities with null checks and error handling
- Update comments and summaries for clarity and maintainability
---
 Text-Grab/Models/ButtonInfo.cs               |  6 +++
 Text-Grab/Utilities/BarcodeUtilities.cs      | 17 +++++++-
 Text-Grab/Utilities/PostGrabActionManager.cs | 44 ++++++++++++++++++--
 3 files changed, 62 insertions(+), 5 deletions(-)

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/Utilities/BarcodeUtilities.cs b/Text-Grab/Utilities/BarcodeUtilities.cs
index 40385f79..45cd0928 100644
--- a/Text-Grab/Utilities/BarcodeUtilities.cs
+++ b/Text-Grab/Utilities/BarcodeUtilities.cs
@@ -14,13 +14,26 @@ public static class BarcodeUtilities
 
     public static OcrOutput TryToReadBarcodes(Bitmap bitmap)
     {
+        if (bitmap is null || bitmap.Width <= 0 || bitmap.Height <= 0)
+            return new OcrOutput() { Kind = OcrOutputKind.Barcode, RawOutput = string.Empty };
+
         BarcodeReader barcodeReader = new()
         {
             AutoRotate = true,
             Options = new ZXing.Common.DecodingOptions { TryHarder = true }
         };
 
-        ZXing.Result result = barcodeReader.Decode(bitmap);
+        Result? result = null;
+
+        try
+        {
+            result = barcodeReader.Decode(bitmap);
+
+        }
+        catch (System.Exception)
+        {
+            return new OcrOutput() { Kind = OcrOutputKind.Barcode, RawOutput = string.Empty };
+        }
 
         string resultString = string.Empty;
         if (result is not null)
@@ -81,4 +94,4 @@ public static SvgImage GetSvgQrCodeForText(string text, ErrorCorrectionLevel cor
 
         return svg;
     }
-}
\ No newline at end of file
+}
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;

From 376b0faefa24f41a4d85981e956c848f8ec960e6 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Sun, 1 Mar 2026 11:30:03 -0600
Subject: [PATCH 04/35] Add new user settings for templates and context menu
 options

Added three user-scoped settings: GrabTemplatesJSON (string), AddToContextMenu (bool), and RegisterOpenWith (bool). Updated App.config, Settings.settings, and Settings.Designer.cs to support these options. Also updated the code generation version in Settings.Designer.cs.
---
 Text-Grab/App.config                      |  9 +++++++++
 Text-Grab/Properties/Settings.Designer.cs | 16 ++++++++++++++--
 Text-Grab/Properties/Settings.settings    |  3 +++
 3 files changed, 26 insertions(+), 2 deletions(-)

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/Properties/Settings.Designer.cs b/Text-Grab/Properties/Settings.Designer.cs
index d223017a..6c4d60c4 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())));
@@ -839,6 +839,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 +862,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..ac20c5b4 100644
--- a/Text-Grab/Properties/Settings.settings
+++ b/Text-Grab/Properties/Settings.settings
@@ -206,6 +206,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>

From 6fb2a4b82cbc94abb49ebd04d7ddacbafab08eba Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Sun, 1 Mar 2026 11:30:21 -0600
Subject: [PATCH 05/35] Handle ApplicationDataContainer size limit exception

Add specific handling for COMException when saving settings
exceeds the ApplicationDataContainer 8 KB size limit. Log a
clear debug message suggesting large data be stored in a file.
Also, clarify the generic exception debug message.
---
 Text-Grab/Services/SettingsService.cs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

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

From 58b7ba37b1c2b31c7f8688444e24f7c5cf38af0c Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Sun, 1 Mar 2026 11:32:04 -0600
Subject: [PATCH 06/35] Add Grab Templates management to Post-Grab Actions
 editor

Introduce a new "Grab Templates" section in the Post-Grab Actions editor, allowing users to create, view, and delete OCR region templates. Add UI for managing templates, including a list view and actions to open the Grab Frame or delete templates. Update Fullscreen Grab settings to link to the template management UI, making template-based OCR more accessible and discoverable. Includes supporting code for loading, refreshing, and deleting templates, as well as minor UI consistency improvements.
---
 Text-Grab/Controls/PostGrabActionEditor.xaml  | 220 ++++++++++++++----
 .../Controls/PostGrabActionEditor.xaml.cs     |  69 ++++++
 Text-Grab/Pages/FullscreenGrabSettings.xaml   |  58 +++--
 .../Pages/FullscreenGrabSettings.xaml.cs      |  12 +
 4 files changed, 297 insertions(+), 62 deletions(-)

diff --git a/Text-Grab/Controls/PostGrabActionEditor.xaml b/Text-Grab/Controls/PostGrabActionEditor.xaml
index 3126b4c2..9f6416f8 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,28 +8,30 @@
     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"
     mc:Ignorable="d">
     <Window.Resources>
-        <ui:ImageIcon x:Key="TextGrabIcon" Source="/Text-Grab;component/Images/TealSelect40.png" />
+        <ui:ImageIcon x:Key="TextGrabIcon"
+                      Source="/Text-Grab;component/Images/TealSelect40.png"/>
 
         <!--  Converter to convert enum to int for ComboBox SelectedIndex  -->
-        <local:EnumToIntConverter x:Key="EnumToIntConverter" />
+        <local:EnumToIntConverter x:Key="EnumToIntConverter"/>
     </Window.Resources>
     <Grid>
         <Grid.ColumnDefinitions>
-            <ColumnDefinition Width="*" />
-            <ColumnDefinition Width="Auto" />
-            <ColumnDefinition Width="*" />
+            <ColumnDefinition Width="*"/>
+            <ColumnDefinition Width="Auto"/>
+            <ColumnDefinition Width="*"/>
         </Grid.ColumnDefinitions>
 
         <Grid.RowDefinitions>
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="*" />
-            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
         </Grid.RowDefinitions>
 
         <ui:TitleBar
@@ -38,7 +40,7 @@
             Height="32"
             Margin="2,2,2,0"
             Padding="8,2"
-            Icon="{StaticResource TextGrabIcon}" />
+            Icon="{StaticResource TextGrabIcon}"/>
 
         <!--  Available Actions (Left)  -->
         <StackPanel
@@ -49,13 +51,13 @@
                 Margin="0,0,0,8"
                 FontSize="18"
                 FontWeight="SemiBold"
-                Text="Available Actions" />
+                Text="Available Actions"/>
             <TextBlock
                 x:Name="AvailableActionsHint"
                 Margin="0,0,0,4"
                 Opacity="0.7"
                 Text="Actions that can be added to the enabled list"
-                TextWrapping="Wrap" />
+                TextWrapping="Wrap"/>
             <Border
                 Background="{ui:ThemeResource CardBackgroundFillColorSecondaryBrush}"
                 BorderBrush="{ui:ThemeResource CardStrokeColorDefaultBrush}"
@@ -64,17 +66,19 @@
                 <Grid>
                     <ui:ListView
                         x:Name="AvailableActionsListBox"
-                        MinHeight="300"
+                        MinHeight="240"
                         d:ItemsSource="{d:SampleData ItemCount=5}"
                         ScrollViewer.HorizontalScrollBarVisibility="Hidden"
                         ScrollViewer.VerticalScrollBarVisibility="Visible">
                         <ListView.View>
                             <GridView>
-                                <GridViewColumn Width="46" Header="Icon">
+                                <GridViewColumn Width="46"
+                                                Header="Icon">
                                     <GridViewColumn.CellTemplate>
                                         <DataTemplate>
                                             <Viewbox Height="24">
-                                                <ui:SymbolIcon FontSize="24" Symbol="{Binding Path=SymbolIcon, Mode=OneWay}" />
+                                                <ui:SymbolIcon FontSize="24"
+                                                               Symbol="{Binding Path=SymbolIcon, Mode=OneWay}"/>
                                             </Viewbox>
                                         </DataTemplate>
                                     </GridViewColumn.CellTemplate>
@@ -82,7 +86,7 @@
                                 <GridViewColumn
                                     Width="300"
                                     DisplayMemberBinding="{Binding ButtonText}"
-                                    Header="Action Name" />
+                                    Header="Action Name"/>
                             </GridView>
                         </ListView.View>
                     </ui:ListView>
@@ -94,7 +98,7 @@
                         FontSize="14"
                         Opacity="0.6"
                         Text="All actions are currently enabled"
-                        Visibility="Collapsed" />
+                        Visibility="Collapsed"/>
                 </Grid>
             </Border>
         </StackPanel>
@@ -113,8 +117,10 @@
                 Click="AddButton_Click"
                 ToolTip="Add selected action to enabled list">
                 <StackPanel Orientation="Horizontal">
-                    <ui:SymbolIcon FontSize="14" Symbol="ArrowRight16" />
-                    <TextBlock Margin="4,0,0,0" Text="Add" />
+                    <ui:SymbolIcon FontSize="14"
+                                   Symbol="ArrowRight16"/>
+                    <TextBlock Margin="4,0,0,0"
+                               Text="Add"/>
                 </StackPanel>
             </ui:Button>
             <ui:Button
@@ -125,11 +131,13 @@
                 Click="RemoveButton_Click"
                 ToolTip="Remove selected action from enabled list">
                 <StackPanel Orientation="Horizontal">
-                    <ui:SymbolIcon FontSize="14" Symbol="ArrowLeft16" />
-                    <TextBlock Margin="4,0,0,0" Text="Remove" />
+                    <ui:SymbolIcon FontSize="14"
+                                   Symbol="ArrowLeft16"/>
+                    <TextBlock Margin="4,0,0,0"
+                               Text="Remove"/>
                 </StackPanel>
             </ui:Button>
-            <Separator Margin="0,8" />
+            <Separator Margin="0,8"/>
             <ui:Button
                 x:Name="MoveUpButton"
                 Width="100"
@@ -138,8 +146,10 @@
                 Click="MoveUpButton_Click"
                 ToolTip="Move selected action up in order">
                 <StackPanel Orientation="Horizontal">
-                    <ui:SymbolIcon FontSize="14" Symbol="ArrowUp16" />
-                    <TextBlock Margin="4,0,0,0" Text="Up" />
+                    <ui:SymbolIcon FontSize="14"
+                                   Symbol="ArrowUp16"/>
+                    <TextBlock Margin="4,0,0,0"
+                               Text="Up"/>
                 </StackPanel>
             </ui:Button>
             <ui:Button
@@ -149,8 +159,10 @@
                 Click="MoveDownButton_Click"
                 ToolTip="Move selected action down in order">
                 <StackPanel Orientation="Horizontal">
-                    <ui:SymbolIcon FontSize="14" Symbol="ArrowDown16" />
-                    <TextBlock Margin="4,0,0,0" Text="Down" />
+                    <ui:SymbolIcon FontSize="14"
+                                   Symbol="ArrowDown16"/>
+                    <TextBlock Margin="4,0,0,0"
+                               Text="Down"/>
                 </StackPanel>
             </ui:Button>
         </StackPanel>
@@ -164,12 +176,12 @@
                 Margin="0,0,0,8"
                 FontSize="18"
                 FontWeight="SemiBold"
-                Text="Enabled Actions" />
+                Text="Enabled Actions"/>
             <TextBlock
                 Margin="0,0,0,4"
                 Opacity="0.7"
                 Text="Actions that will appear in the post-grab menu"
-                TextWrapping="Wrap" />
+                TextWrapping="Wrap"/>
             <Border
                 Background="{ui:ThemeResource CardBackgroundFillColorSecondaryBrush}"
                 BorderBrush="{ui:ThemeResource CardStrokeColorDefaultBrush}"
@@ -177,17 +189,19 @@
                 CornerRadius="8">
                 <ui:ListView
                     x:Name="EnabledActionsListBox"
-                    MinHeight="300"
+                    MinHeight="240"
                     d:ItemsSource="{d:SampleData ItemCount=5}"
                     ScrollViewer.HorizontalScrollBarVisibility="Hidden"
                     ScrollViewer.VerticalScrollBarVisibility="Visible">
                     <ListView.View>
                         <GridView>
-                            <GridViewColumn Width="46" Header="Icon">
+                            <GridViewColumn Width="46"
+                                            Header="Icon">
                                 <GridViewColumn.CellTemplate>
                                     <DataTemplate>
                                         <Viewbox Height="24">
-                                            <ui:SymbolIcon FontSize="24" Symbol="{Binding Path=SymbolIcon, Mode=OneWay}" />
+                                            <ui:SymbolIcon FontSize="24"
+                                                           Symbol="{Binding Path=SymbolIcon, Mode=OneWay}"/>
                                         </Viewbox>
                                     </DataTemplate>
                                 </GridViewColumn.CellTemplate>
@@ -195,14 +209,16 @@
                             <GridViewColumn
                                 Width="180"
                                 DisplayMemberBinding="{Binding ButtonText}"
-                                Header="Action Name" />
-                            <GridViewColumn Width="120" Header="Default">
+                                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 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>
@@ -217,12 +233,130 @@
                 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" />
+                ToolTip="When enabled, the post-grab menu stays open after clicking an action, allowing multiple actions to be selected"/>
         </StackPanel>
 
+        <!--  Grab Templates Section  -->
+        <Border
+            Grid.Row="2"
+            Grid.Column="0"
+            Grid.ColumnSpan="3"
+            Margin="16,0,16,8"
+            BorderBrush="{ui:ThemeResource CardStrokeColorDefaultBrush}"
+            BorderThickness="1"
+            CornerRadius="8"
+            Background="{ui:ThemeResource CardBackgroundFillColorSecondaryBrush}">
+            <Grid Margin="12,10">
+                <Grid.RowDefinitions>
+                    <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
+                            Opacity="0.7"
+                            FontSize="11"
+                            Text="Templates extract structured data from fixed-layout documents. Open a Grab Frame, use Ctrl+drag to draw regions, then click the Save as Template button. Add a template to the Enabled Actions list to use it during a Fullscreen Grab."
+                            TextWrapping="Wrap"/>
+                    </StackPanel>
+
+                    <StackPanel
+                        Grid.Column="1"
+                        Orientation="Horizontal"
+                        VerticalAlignment="Center">
+                        <ui:Button
+                            x:Name="OpenGrabFrameButton"
+                            Margin="0,0,6,0"
+                            Click="OpenGrabFrameButton_Click"
+                            ToolTip="Open a Grab Frame to draw regions and save as a template">
+                            <StackPanel Orientation="Horizontal">
+                                <ui:SymbolIcon FontSize="14"
+                                               Symbol="Window24"/>
+                                <TextBlock Margin="4,0,0,0"
+                                           Text="Open Grab Frame"/>
+                            </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"
+                        MaxHeight="140"
+                        ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                        ScrollViewer.VerticalScrollBarVisibility="Auto">
+                        <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 Text="{Binding LastUsedDate, StringFormat={}{0:g}}"
+                                                       Opacity="0.7"/>
+                                        </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>
+            </Grid>
+        </Border>
+
         <!--  Bottom Buttons  -->
         <StackPanel
-            Grid.Row="2"
+            Grid.Row="3"
             Grid.Column="0"
             Grid.ColumnSpan="3"
             Margin="16,8"
@@ -233,19 +367,19 @@
                 Margin="0,0,8,0"
                 Click="ResetButton_Click"
                 Content="Reset to Defaults"
-                ToolTip="Reset to default post-grab actions" />
+                ToolTip="Reset to default post-grab actions"/>
             <ui:Button
                 x:Name="SaveButton"
                 Margin="0,0,8,0"
                 Appearance="Primary"
                 Click="SaveButton_Click"
                 Content="Save"
-                ToolTip="Save changes and close" />
+                ToolTip="Save changes and close"/>
             <ui:Button
                 x:Name="CancelButton"
                 Click="CancelButton_Click"
                 Content="Cancel"
-                ToolTip="Close without saving" />
+                ToolTip="Close without saving"/>
         </StackPanel>
     </Grid>
 </ui:FluentWindow>
diff --git a/Text-Grab/Controls/PostGrabActionEditor.xaml.cs b/Text-Grab/Controls/PostGrabActionEditor.xaml.cs
index a050266a..c82d375d 100644
--- a/Text-Grab/Controls/PostGrabActionEditor.xaml.cs
+++ b/Text-Grab/Controls/PostGrabActionEditor.xaml.cs
@@ -7,6 +7,7 @@
 using System.Windows.Data;
 using Text_Grab.Models;
 using Text_Grab.Utilities;
+using Text_Grab.Views;
 using Wpf.Ui.Controls;
 
 namespace Text_Grab.Controls;
@@ -73,6 +74,9 @@ public PostGrabActionEditor()
 
         // Update empty state visibility
         UpdateEmptyStateVisibility();
+
+        // Load templates
+        LoadTemplates();
     }
 
     #endregion Constructors
@@ -199,5 +203,70 @@ 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 OpenGrabFrameButton_Click(object sender, RoutedEventArgs e)
+    {
+        GrabFrame grabFrame = new();
+        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();
+    }
+
     #endregion Methods
 }
diff --git a/Text-Grab/Pages/FullscreenGrabSettings.xaml b/Text-Grab/Pages/FullscreenGrabSettings.xaml
index 54a6c2a2..57d04d05 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,44 @@
                 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>
 
         <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 +95,7 @@
             <TextBlock
                 VerticalAlignment="Center"
                 Style="{StaticResource TextBodyNormal}"
-                Text="Insert delay (seconds):" />
+                Text="Insert delay (seconds):"/>
             <Slider
                 x:Name="InsertDelaySlider"
                 Width="200"
@@ -102,33 +105,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 +139,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..4d63762c 100644
--- a/Text-Grab/Pages/FullscreenGrabSettings.xaml.cs
+++ b/Text-Grab/Pages/FullscreenGrabSettings.xaml.cs
@@ -134,6 +134,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();

From 61af2a08e1436473118196f59c07861efe96c1d3 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Sun, 1 Mar 2026 11:32:36 -0600
Subject: [PATCH 07/35] Add Grab Template creation and overlay support

Users can now define and save "Grab Templates" in the Grab Frame window by Ctrl+dragging regions and using a new "Save as Template" button. Templates store region layouts for structured extraction in fullscreen grabs. Added UI for naming and formatting templates, and logic to display template region overlays during fullscreen selection. Post-grab actions now receive region context for template-based processing. Includes XAML cleanup and is fully opt-in via Post-Grab Actions settings.
---
 Text-Grab/Views/FullscreenGrab.xaml    |   3 +
 Text-Grab/Views/FullscreenGrab.xaml.cs | 112 ++++-
 Text-Grab/Views/GrabFrame.xaml         | 585 ++++++++++++++-----------
 Text-Grab/Views/GrabFrame.xaml.cs      |  71 +++
 4 files changed, 515 insertions(+), 256 deletions(-)

diff --git a/Text-Grab/Views/FullscreenGrab.xaml b/Text-Grab/Views/FullscreenGrab.xaml
index 5011adc1..e6fedeb3 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml
+++ b/Text-Grab/Views/FullscreenGrab.xaml
@@ -112,6 +112,9 @@
                 </ContextMenu>
             </Canvas.ContextMenu>
         </Canvas>
+        <Canvas
+            x:Name="TemplateOverlayHost"
+            IsHitTestVisible="False" />
         <Border
             x:Name="TopButtonsStackPanel"
             Margin="12"
diff --git a/Text-Grab/Views/FullscreenGrab.xaml.cs b/Text-Grab/Views/FullscreenGrab.xaml.cs
index 7027068b..a9a15a67 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml.cs
+++ b/Text-Grab/Views/FullscreenGrab.xaml.cs
@@ -44,6 +44,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;
@@ -274,7 +275,7 @@ private void LoadDynamicPostGrabActions()
 
         // 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;
 
@@ -378,6 +379,80 @@ private void FullscreenGrab_KeyUp(object sender, KeyEventArgs e)
         }
     }
 
+    private GrabTemplate? GetActiveTemplate()
+    {
+        if (NextStepDropDownButton.Flyout is not ContextMenu contextMenu)
+            return null;
+
+        foreach (object item in contextMenu.Items)
+        {
+            if (item is MenuItem menuItem
+                && 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.
+    /// Regions are scaled using UniformToFill semantics relative to the template's
+    /// reference image dimensions so they fill the selected area proportionally.
+    /// </summary>
+    private void UpdateTemplateRegionOverlays(double selLeft, double selTop, double selWidth, double selHeight)
+    {
+        TemplateOverlayHost.Children.Clear();
+        templateOverlayCanvas.Children.Clear();
+
+        GrabTemplate? template = GetActiveTemplate();
+        if (template is null || template.Regions.Count == 0)
+            return;
+
+        if (selWidth < 4 || selHeight < 4)
+            return;
+
+        // Stretch: scale each axis independently to fill the selection exactly
+        double scaleX = selWidth / template.ReferenceImageWidth;
+        double scaleY = selHeight / template.ReferenceImageHeight;
+
+        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);
+
+        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;
+
+            Border regionBorder = new()
+            {
+                Width = regionWidth,
+                Height = regionHeight,
+                BorderBrush = new SolidColorBrush(borderColor),
+                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();
@@ -580,6 +655,8 @@ private void PanSelection(System.Windows.Point movingPoint)
             new System.Windows.Size(selectBorder.Width - 2, selectBorder.Height - 2));
         Canvas.SetLeft(selectBorder, leftValue - 1);
         Canvas.SetTop(selectBorder, topValue - 1);
+
+        UpdateTemplateRegionOverlays(leftValue - 1, topValue - 1, selectBorder.Width, selectBorder.Height);
     }
 
     private void PlaceGrabFrameInSelectionRect()
@@ -652,6 +729,8 @@ private void RegionClickCanvas_MouseDown(object sender, MouseButtonEventArgs e)
         dpiScale = VisualTreeHelper.GetDpi(this);
 
         try { RegionClickCanvas.Children.Remove(selectBorder); } catch (Exception) { }
+        TemplateOverlayHost.Children.Clear();
+        templateOverlayCanvas.Children.Clear();
 
         selectBorder.BorderThickness = new Thickness(2);
         System.Windows.Media.Color borderColor = System.Windows.Media.Color.FromArgb(255, 40, 118, 126);
@@ -697,6 +776,8 @@ private void RegionClickCanvas_MouseMove(object sender, MouseEventArgs e)
             new System.Windows.Size(selectBorder.Width - 2, selectBorder.Height - 2));
         Canvas.SetLeft(selectBorder, left - 1);
         Canvas.SetTop(selectBorder, top - 1);
+
+        UpdateTemplateRegionOverlays(left - 1, top - 1, selectBorder.Width, selectBorder.Height);
     }
 
     private async void RegionClickCanvas_MouseUp(object sender, MouseButtonEventArgs e)
@@ -712,6 +793,9 @@ private async void RegionClickCanvas_MouseUp(object sender, MouseButtonEventArgs
             new System.Windows.Point(0, 0),
             new System.Windows.Size(0, 0));
 
+        TemplateOverlayHost.Children.Clear();
+        templateOverlayCanvas.Children.Clear();
+
         System.Windows.Point movingPoint = e.GetPosition(this);
         Matrix m = PresentationSource.FromVisual(this).CompositionTarget.TransformToDevice;
         movingPoint.X *= m.M11;
@@ -729,6 +813,14 @@ private async void RegionClickCanvas_MouseUp(object sender, MouseButtonEventArgs
             (int)(selectBorder.Width * m.M11),
             (int)(selectBorder.Height * m.M22));
 
+        // Build the absolute capture rect for template execution (physical screen pixels)
+        System.Windows.Point absoluteWindowPos = this.GetAbsolutePosition();
+        Rect absoluteCaptureRect = new(
+            absoluteWindowPos.X + xDimScaled,
+            absoluteWindowPos.Y + yDimScaled,
+            selectBorder.Width * m.M11,
+            selectBorder.Height * m.M22);
+
         TextFromOCR = string.Empty;
 
         if (NewGrabFrameMenuItem.IsChecked is true)
@@ -779,7 +871,7 @@ private async void RegionClickCanvas_MouseUp(object sender, MouseButtonEventArgs
                 PositionRect = historyRect,
                 IsTable = TableToggleButton.IsChecked!.Value,
                 TextContent = TextFromOCR,
-                ImageContent = Singleton<HistoryService>.Instance.CachedBitmap,
+                ImageContent = Singleton<HistoryService>.Instance.CachedBitmap is Bitmap cb ? new Bitmap(cb) : null,
                 SourceMode = TextGrabMode.Fullscreen,
             };
         }
@@ -807,8 +899,16 @@ private async void RegionClickCanvas_MouseUp(object sender, MouseButtonEventArgs
                         continue;
                     }
 
+                    // Build context for this action (text may have changed from previous actions)
+                    PostGrabContext grabContext = new(
+                        Text: TextFromOCR ?? string.Empty,
+                        CaptureRegion: absoluteCaptureRect,
+                        DpiScale: m.M11,
+                        CapturedImage: null,
+                        Language: selectedOcrLang);
+
                     // Execute the action
-                    TextFromOCR = await PostGrabActionManager.ExecutePostGrabAction(action, TextFromOCR);
+                    TextFromOCR = await PostGrabActionManager.ExecutePostGrabAction(action, grabContext);
                 }
             }
 
@@ -1021,7 +1121,7 @@ private void Window_Unloaded(object sender, RoutedEventArgs e)
         if (NextStepDropDownButton.Flyout is ContextMenu contextMenu)
         {
             contextMenu.PreviewKeyDown -= FullscreenGrab_KeyDown;
-            
+
             foreach (object item in contextMenu.Items)
             {
                 if (item is MenuItem menuItem)
@@ -1043,7 +1143,7 @@ private void Window_Unloaded(object sender, RoutedEventArgs e)
                     }
                 }
             }
-            
+
             contextMenu.Items.Clear();
         }
 
@@ -1137,7 +1237,7 @@ 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 
+        if (sender is MenuItem menuItem
             && menuItem.Tag is ButtonInfo action
             && action.DefaultCheckState == DefaultCheckState.LastUsed)
         {
diff --git a/Text-Grab/Views/GrabFrame.xaml b/Text-Grab/Views/GrabFrame.xaml
index fecddb79..3eb7a778 100644
--- a/Text-Grab/Views/GrabFrame.xaml
+++ b/Text-Grab/Views/GrabFrame.xaml
@@ -37,14 +37,21 @@
     WindowStyle="None"
     mc:Ignorable="d">
     <Window.Resources>
-        <BitmapImage x:Key="TextGrabIcon" UriSource="/Text-Grab;component/Images/TealSelect40.png" />
+        <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 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>
 
@@ -52,31 +59,31 @@
         <CommandBinding
             CanExecute="CanPasteExecute"
             Command="{x:Static local:GrabFrame.PasteCommand}"
-            Executed="PasteExecuted" />
+            Executed="PasteExecuted"/>
         <CommandBinding
             CanExecute="CanUndoCommand"
             Command="{x:Static local:GrabFrame.UndoCommand}"
-            Executed="UndoExecuted" />
+            Executed="UndoExecuted"/>
         <CommandBinding
             CanExecute="CanRedoExecuted"
             Command="{x:Static local:GrabFrame.RedoCommand}"
-            Executed="RedoExecuted" />
+            Executed="RedoExecuted"/>
         <CommandBinding
             CanExecute="CanExecuteMergeWordBorders"
             Command="{x:Static local:GrabFrame.DeleteWordsCommand}"
-            Executed="DeleteWordBordersExecuted" />
+            Executed="DeleteWordBordersExecuted"/>
         <CommandBinding
             CanExecute="CanChangeWordBorderExecute"
             Command="{x:Static local:GrabFrame.MergeWordsCommand}"
-            Executed="MergeWordBordersExecuted" />
+            Executed="MergeWordBordersExecuted"/>
         <CommandBinding
             CanExecute="CanExecuteGrab"
             Command="{x:Static local:GrabFrame.GrabCommand}"
-            Executed="GrabExecuted" />
+            Executed="GrabExecuted"/>
         <CommandBinding
             CanExecute="CanExecuteGrab"
             Command="{x:Static local:GrabFrame.GrabTrimCommand}"
-            Executed="GrabTrimExecuted" />
+            Executed="GrabTrimExecuted"/>
     </Window.CommandBindings>
 
     <WindowChrome.WindowChrome>
@@ -84,7 +91,7 @@
             CaptionHeight="32"
             CornerRadius="18,18,2,18"
             GlassFrameThickness="0"
-            ResizeBorderThickness="5" />
+            ResizeBorderThickness="5"/>
     </WindowChrome.WindowChrome>
     <Border
         BorderBrush="{ui:ThemeResource ApplicationBackgroundBrush}"
@@ -92,9 +99,10 @@
         ClipToBounds="True">
         <Grid ClipToBounds="False">
             <Grid.RowDefinitions>
-                <RowDefinition Height="32" />
-                <RowDefinition Height="*" />
-                <RowDefinition Height="auto" />
+                <RowDefinition Height="32"/>
+                <RowDefinition Height="*"/>
+                <RowDefinition Height="Auto"/>
+                <RowDefinition Height="auto"/>
             </Grid.RowDefinitions>
             <Grid
                 Grid.Row="0"
@@ -102,11 +110,11 @@
                 VerticalAlignment="Top"
                 Background="{ui:ThemeResource ApplicationBackgroundBrush}">
                 <Grid.ColumnDefinitions>
-                    <ColumnDefinition Width="Auto" />
-                    <ColumnDefinition Width="*" />
-                    <ColumnDefinition Width="Auto" />
-                    <ColumnDefinition Width="Auto" />
-                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="*"/>
+                    <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="Auto"/>
                 </Grid.ColumnDefinitions>
 
                 <Menu
@@ -114,224 +122,227 @@
                     VerticalAlignment="Center"
                     ClipToBounds="True"
                     WindowChrome.IsHitTestVisibleInChrome="True">
-                    <MenuItem Header="File" SubmenuOpened="MenuItem_SubmenuOpened">
+                    <MenuItem Header="File"
+                            SubmenuOpened="MenuItem_SubmenuOpened">
                         <MenuItem
                             x:Name="AutoOcrCheckBox"
                             Click="AutoOcrCheckBox_Click"
                             Header="Auto Start OCR"
                             IsCheckable="True"
-                            IsChecked="True" />
+                            IsChecked="True"/>
                         <MenuItem
                             x:Name="AlwaysUpdateEtwCheckBox"
                             Header="Auto Update Content in Edit Text Window"
                             IsCheckable="True"
-                            IsChecked="True" />
+                            IsChecked="True"/>
                         <MenuItem
                             x:Name="ReadBarcodesMenuItem"
                             Checked="ReadBarcodesMenuItem_Checked"
                             Header="Try to read barcodes and QR Codes"
                             IsCheckable="True"
-                            Unchecked="ReadBarcodesMenuItem_Checked" />
+                            Unchecked="ReadBarcodesMenuItem_Checked"/>
                         <MenuItem
                             x:Name="IsTopmostMenuItem"
                             Header="Keep Grab Frame On Top"
                             IsCheckable="True"
-                            IsChecked="{Binding Topmost, ElementName=GrabFrameWindow, Mode=TwoWay}" />
-                        <Separator />
-                        <MenuItem x:Name="TranslationMenuItem" Header="Translation to...">
+                            IsChecked="{Binding Topmost, ElementName=GrabFrameWindow, Mode=TwoWay}"/>
+                        <Separator/>
+                        <MenuItem x:Name="TranslationMenuItem"
+                                Header="Translation to...">
                             <MenuItem
                                 x:Name="EnableTranslationMenuItem"
                                 Click="EnableTranslationMenuItem_Click"
                                 Header="Enable Real-time Translation"
-                                IsCheckable="True" />
-                            <Separator />
+                                IsCheckable="True"/>
+                            <Separator/>
                             <MenuItem Header="Target Language">
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="English"
                                     IsCheckable="True"
-                                    Tag="English" />
+                                    Tag="English"/>
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Spanish"
                                     IsCheckable="True"
-                                    Tag="Spanish" />
+                                    Tag="Spanish"/>
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="French"
                                     IsCheckable="True"
-                                    Tag="French" />
+                                    Tag="French"/>
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="German"
                                     IsCheckable="True"
-                                    Tag="German" />
+                                    Tag="German"/>
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Italian"
                                     IsCheckable="True"
-                                    Tag="Italian" />
+                                    Tag="Italian"/>
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Portuguese"
                                     IsCheckable="True"
-                                    Tag="Portuguese" />
+                                    Tag="Portuguese"/>
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Russian"
                                     IsCheckable="True"
-                                    Tag="Russian" />
+                                    Tag="Russian"/>
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Japanese"
                                     IsCheckable="True"
-                                    Tag="Japanese" />
+                                    Tag="Japanese"/>
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Chinese (Simplified)"
                                     IsCheckable="True"
-                                    Tag="Chinese (Simplified)" />
+                                    Tag="Chinese (Simplified)"/>
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Korean"
                                     IsCheckable="True"
-                                    Tag="Korean" />
+                                    Tag="Korean"/>
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Arabic"
                                     IsCheckable="True"
-                                    Tag="Arabic" />
+                                    Tag="Arabic"/>
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Hindi"
                                     IsCheckable="True"
-                                    Tag="Hindi" />
+                                    Tag="Hindi"/>
                             </MenuItem>
                         </MenuItem>
-                        <Separator />
+                        <Separator/>
                         <MenuItem
                             Command="{x:Static local:GrabFrame.PasteCommand}"
                             Header="Paste Image"
-                            InputGestureText="Ctrl + Shift + V" />
+                            InputGestureText="Ctrl + Shift + V"/>
                         <MenuItem
                             Click="OpenImageMenuItem_Click"
                             Header="Open Image..."
-                            InputGestureText="Ctrl + O" />
-                        <MenuItem x:Name="OpenRecentGrabsMenuItem" Header="Recent Grabs" />
-                        <Separator />
+                            InputGestureText="Ctrl + O"/>
+                        <MenuItem x:Name="OpenRecentGrabsMenuItem"
+                                Header="Recent Grabs"/>
+                        <Separator/>
                         <MenuItem
                             Name="GrabMenuItem"
                             Command="{x:Static local:GrabFrame.GrabCommand}"
                             Header="_Grab"
-                            InputGestureText="Ctrl + G" />
+                            InputGestureText="Ctrl + G"/>
                         <MenuItem
                             Name="GrabTrimSingleMenuItem"
                             Command="{x:Static local:GrabFrame.GrabTrimCommand}"
                             Header="Grab text as Single Line"
-                            InputGestureText="Ctrl + Shift + G" />
-                        <Separator />
+                            InputGestureText="Ctrl + Shift + G"/>
+                        <Separator/>
                         <MenuItem
                             Name="SettingsMenuItem"
                             Click="SettingsBTN_Click"
-                            Header="Text Grab Settings" />
+                            Header="Text Grab Settings"/>
                         <MenuItem
                             Name="CloseMenuItem"
                             Click="OnCloseButtonClick"
                             Header="Close"
-                            InputGestureText="Alt + F4" />
+                            InputGestureText="Alt + F4"/>
                     </MenuItem>
                     <MenuItem Header="Edit">
                         <MenuItem
                             Name="RedoMenuItem"
                             Command="{x:Static local:GrabFrame.RedoCommand}"
                             Header="Redo"
-                            InputGestureText="Ctrl + Y" />
+                            InputGestureText="Ctrl + Y"/>
                         <MenuItem
                             Name="UndoMenuItem"
                             Command="{x:Static local:GrabFrame.UndoCommand}"
                             Header="Undo"
-                            InputGestureText="Ctrl + Z" />
+                            InputGestureText="Ctrl + Z"/>
                         <MenuItem
                             Name="SelectAllMenuItem"
                             Click="SelectAllWordBorders"
                             Header="Select All"
-                            InputGestureText="Ctrl + A" />
+                            InputGestureText="Ctrl + A"/>
                         <MenuItem
                             Name="AddEditOcrMenuItem"
                             Header="Add, move, or Resize lines"
                             InputGestureText="Hold Ctrl"
-                            IsCheckable="True" />
-                        <Separator />
+                            IsCheckable="True"/>
+                        <Separator/>
                         <MenuItem Header="Edit Image">
                             <MenuItem
                                 Name="InvertColorsMI"
                                 Click="InvertColorsMI_Click"
-                                Header="Invert Colors" />
+                                Header="Invert Colors"/>
                             <MenuItem
                                 Name="AutoContrastMI"
                                 Click="AutoContrastMI_Click"
-                                Header="Increase Contrast (Sigmoid)" />
+                                Header="Increase Contrast (Sigmoid)"/>
                             <MenuItem
                                 Name="BrightenMI"
                                 Click="BrightenMI_Click"
-                                Header="Brighten" />
+                                Header="Brighten"/>
                             <MenuItem
                                 Name="DarkenMI"
                                 Click="DarkenMI_Click"
-                                Header="Darken" />
+                                Header="Darken"/>
                             <MenuItem
                                 Name="GrayscaleMI"
                                 Click="GrayscaleMI_Click"
-                                Header="Grayscale" />
+                                Header="Grayscale"/>
                         </MenuItem>
                         <MenuItem
                             Click="RefreshBTN_Click"
                             Header="Refresh Grab Frame OCR Results"
-                            InputGestureText="(Ctrl + R)" />
+                            InputGestureText="(Ctrl + R)"/>
                         <MenuItem
                             Checked="AspectRationMI_Checked"
                             Header="Maintain Aspect Ratio"
                             IsCheckable="True"
                             IsChecked="{Binding IsChecked, ElementName=AspectRationMI, Mode=TwoWay}"
-                            Unchecked="AspectRationMI_Checked" />
+                            Unchecked="AspectRationMI_Checked"/>
                         <MenuItem
                             Click="FreezeToggleButton_Click"
                             Header="Freeze Image In Frame"
                             InputGestureText="F"
                             IsCheckable="True"
-                            IsChecked="{Binding IsChecked, ElementName=FreezeToggleButton, Mode=TwoWay}" />
+                            IsChecked="{Binding IsChecked, ElementName=FreezeToggleButton, Mode=TwoWay}"/>
                         <MenuItem
                             Click="TableToggleButton_Click"
                             Header="Analyze as a Table"
                             InputGestureText="T"
                             IsCheckable="True"
-                            IsChecked="{Binding IsChecked, ElementName=TableToggleButton, Mode=TwoWay}" />
+                            IsChecked="{Binding IsChecked, ElementName=TableToggleButton, Mode=TwoWay}"/>
                         <MenuItem
                             Click="EditToggleButton_Click"
                             Header="Allow recognized words to be edited"
                             IsCheckable="True"
-                            IsChecked="{Binding IsChecked, ElementName=EditToggleButton, Mode=TwoWay}" />
+                            IsChecked="{Binding IsChecked, ElementName=EditToggleButton, Mode=TwoWay}"/>
                         <MenuItem
                             Click="EditTextBTN_Click"
                             Header="Send results to an Edit Text Window"
                             InputGestureText="E"
                             IsCheckable="True"
-                            IsChecked="{Binding IsChecked, ElementName=EditTextToggleButton, Mode=TwoWay}" />
-                        <Separator />
+                            IsChecked="{Binding IsChecked, ElementName=EditTextToggleButton, Mode=TwoWay}"/>
+                        <Separator/>
                         <MenuItem
                             x:Name="InvertSelectionMenuItem"
                             Click="InvertSelection"
                             Header="Invert Selection"
-                            InputGestureText="Ctrl + I" />
+                            InputGestureText="Ctrl + I"/>
                         <MenuItem
                             Command="{x:Static local:GrabFrame.MergeWordsCommand}"
                             Header="Merge Word Borders"
-                            InputGestureText="Ctrl + M" />
+                            InputGestureText="Ctrl + M"/>
                         <MenuItem
                             Command="{x:Static local:GrabFrame.DeleteWordsCommand}"
                             Header="_Delete selected words"
-                            InputGestureText="Del" />
-                        <Separator />
+                            InputGestureText="Del"/>
+                        <Separator/>
                     </MenuItem>
                     <MenuItem Header="View">
                         <ui:MenuItem
@@ -339,43 +350,43 @@
                             Click="ScrollBehaviorMenuItem_Click"
                             Header="Scroll does nothing"
                             IsCheckable="True"
-                            Tag="None" />
+                            Tag="None"/>
                         <MenuItem
                             x:Name="ResizeScrollMenuItem"
                             Click="ScrollBehaviorMenuItem_Click"
                             Header="Scroll resizes Grab Frame"
                             IsCheckable="True"
-                            Tag="Resize" />
+                            Tag="Resize"/>
                         <MenuItem
                             x:Name="ZoomScrollMenuItem"
                             Click="ScrollBehaviorMenuItem_Click"
                             Header="Scroll Zooms Grab Frame (preview)"
                             IsCheckable="True"
-                            Tag="Zoom" />
-                        <Separator />
+                            Tag="Zoom"/>
+                        <Separator/>
                         <MenuItem
                             x:Name="CloseOnGrabMenuItem"
                             Click="CloseOnGrabMenuItem_Click"
                             Header="Close Frame on Grab"
-                            IsCheckable="True" />
+                            IsCheckable="True"/>
                     </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>
                 <StackPanel
@@ -395,8 +406,10 @@
                         <Image.Style>
                             <Style TargetType="Image">
                                 <Style.Triggers>
-                                    <DataTrigger Binding="{Binding IsActive, RelativeSource={RelativeSource AncestorType=Window}}" Value="False">
-                                        <Setter Property="Opacity" Value="0.6" />
+                                    <DataTrigger Binding="{Binding IsActive, RelativeSource={RelativeSource AncestorType=Window}}"
+                                            Value="False">
+                                        <Setter Property="Opacity"
+                                                Value="0.6"/>
                                     </DataTrigger>
                                 </Style.Triggers>
                             </Style>
@@ -411,8 +424,10 @@
                         <TextBlock.Style>
                             <Style TargetType="TextBlock">
                                 <Style.Triggers>
-                                    <DataTrigger Binding="{Binding IsActive, RelativeSource={RelativeSource AncestorType=Window}}" Value="False">
-                                        <Setter Property="Opacity" Value="0.6" />
+                                    <DataTrigger Binding="{Binding IsActive, RelativeSource={RelativeSource AncestorType=Window}}"
+                                            Value="False">
+                                        <Setter Property="Opacity"
+                                                Value="0.6"/>
                                     </DataTrigger>
                                 </Style.Triggers>
                             </Style>
@@ -427,7 +442,7 @@
                     Padding="8,2"
                     HorizontalAlignment="Right"
                     Background="{ui:ThemeResource ApplicationBackgroundBrush}"
-                    WindowChrome.IsHitTestVisibleInChrome="True" />
+                    WindowChrome.IsHitTestVisibleInChrome="True"/>
                 <StackPanel
                     Grid.Column="2"
                     Orientation="Horizontal"
@@ -439,7 +454,8 @@
                         Margin="0,-2,0,0"
                         Click="OnMinimizeButtonClick"
                         Style="{StaticResource TitleBarButtonStyle}">
-                        <TextBlock FontFamily="Segoe MDL2 Assets" Text="" />
+                        <TextBlock FontFamily="Segoe MDL2 Assets"
+                                Text=""/>
                     </Button>
                     <Button
                         x:Name="RestoreButton"
@@ -451,7 +467,7 @@
                         <TextBlock
                             x:Name="RestoreTextlock"
                             FontFamily="Segoe MDL2 Assets"
-                            Text="" />
+                            Text=""/>
                     </Button>
                     <Button
                         x:Name="CloseButton"
@@ -460,7 +476,8 @@
                         Margin="0,-2,0,0"
                         Click="OnCloseButtonClick"
                         Style="{StaticResource TitleBarCloseButtonStyle}">
-                        <TextBlock FontFamily="Segoe MDL2 Assets" Text="" />
+                        <TextBlock FontFamily="Segoe MDL2 Assets"
+                                Text=""/>
                     </Button>
 
                 </StackPanel>
@@ -470,7 +487,8 @@
                 Grid.Row="1"
                 ClipToBounds="True">
                 <Border.Background>
-                    <SolidColorBrush Opacity=".05" Color="White" />
+                    <SolidColorBrush Opacity=".05"
+                            Color="White"/>
                 </Border.Background>
                 <Grid>
                     <controls:ZoomBorder x:Name="MainZoomBorder">
@@ -482,7 +500,7 @@
                                     HorizontalAlignment="Center"
                                     VerticalAlignment="Center"
                                     Opacity="0"
-                                    Stretch="Uniform" />
+                                    Stretch="Uniform"/>
                                 <Canvas
                                     x:Name="RectanglesCanvas"
                                     Margin="-4,-2,0,0"
@@ -492,147 +510,202 @@
                                     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 ({1}, {2}…):"
+                        ToolTip="Use {1}, {2}, etc. for region values. Regions are numbered left-to-right, top-to-bottom."/>
+                    <TextBox
+                        x:Name="OutputTemplateBox"
+                        Grid.Column="3"
+                        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."/>
+                    <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"
                     HorizontalAlignment="Stretch"
                     VerticalAlignment="Bottom">
                     <Grid.ColumnDefinitions>
-                        <ColumnDefinition Width="auto" />
-                        <ColumnDefinition Width="*" />
-                        <ColumnDefinition Width="auto" />
-                        <ColumnDefinition Width="auto" />
-                        <ColumnDefinition Width="auto" />
-                        <ColumnDefinition Width="110" />
+                        <ColumnDefinition Width="auto"/>
+                        <ColumnDefinition Width="*"/>
+                        <ColumnDefinition Width="auto"/>
+                        <ColumnDefinition Width="auto"/>
+                        <ColumnDefinition Width="auto"/>
+                        <ColumnDefinition Width="110"/>
                     </Grid.ColumnDefinitions>
 
                     <TextBox
@@ -645,20 +718,20 @@
                         TextChanged="SearchBox_TextChanged">
                         <TextBox.ContextMenu>
                             <ContextMenu>
-                                <MenuItem Command="ApplicationCommands.Cut" />
-                                <MenuItem Command="ApplicationCommands.Copy" />
-                                <MenuItem Command="ApplicationCommands.Paste" />
-                                <Separator />
+                                <MenuItem Command="ApplicationCommands.Cut"/>
+                                <MenuItem Command="ApplicationCommands.Copy"/>
+                                <MenuItem Command="ApplicationCommands.Paste"/>
+                                <Separator/>
                                 <MenuItem
                                     x:Name="SearchWithRegexCheckBox"
                                     Click="SearchBox_GotFocus"
                                     Header="Search with Regex"
-                                    IsCheckable="True" />
+                                    IsCheckable="True"/>
                                 <MenuItem
                                     x:Name="ExactMatchChkBx"
                                     Click="SearchBox_GotFocus"
                                     Header="Match searches exactly"
-                                    IsCheckable="True" />
+                                    IsCheckable="True"/>
                             </ContextMenu>
                         </TextBox.ContextMenu>
                     </TextBox>
@@ -672,7 +745,7 @@
                         Foreground="{ui:ThemeResource TextFillColorSecondaryBrush}"
                         IsHitTestVisible="False"
                         Opacity="0.5"
-                        Visibility="{Binding Visibility, ElementName=SearchBox, Mode=OneWay}" />
+                        Visibility="{Binding Visibility, ElementName=SearchBox, Mode=OneWay}"/>
                     <controls:CollapsibleButton
                         x:Name="ClearBTN"
                         Grid.Column="1"
@@ -684,7 +757,7 @@
                         Click="ClearBTN_Click"
                         Foreground="LightGray"
                         IsSymbol="True"
-                        Visibility="Collapsed" />
+                        Visibility="Collapsed"/>
 
                     <Menu
                         x:Name="MatchesMenu"
@@ -702,14 +775,15 @@
                                     x:Name="MatchesTXTBLK"
                                     HorizontalAlignment="Left"
                                     VerticalAlignment="Center"
-                                    Text="Matches: 0" />
+                                    Text="Matches: 0"/>
                             </MenuItem.Header>
-                            <MenuItem Click="HandleDelete" Header="Delete Selected" />
-                            <Separator />
+                            <MenuItem Click="HandleDelete"
+                                    Header="Delete Selected"/>
+                            <Separator/>
                             <MenuItem
                                 Name="EditMatchesMenuItem"
                                 Click="EditMatchesMenuItem_Click"
-                                Header="Edit Selected in new Window" />
+                                Header="Edit Selected in new Window"/>
                         </MenuItem>
                     </Menu>
 
@@ -728,7 +802,7 @@
                                     VerticalAlignment="Center"
                                     FontFamily="Segoe UI"
                                     Style="{StaticResource SymbolTextStyle}"
-                                    Text="{Binding LanguageTag}" />
+                                    Text="{Binding LanguageTag}"/>
                             </DataTemplate>
                         </ComboBox.ItemTemplate>
                     </ComboBox>
@@ -747,7 +821,7 @@
                             ButtonText="Re-OCR Frame"
                             Click="RefreshBTN_Click"
                             IsSymbol="True"
-                            ToolTip="Re-OCR Frame (Ctrl + R)" />
+                            ToolTip="Re-OCR Frame (Ctrl + R)"/>
                         <controls:CollapsibleButton
                             x:Name="OcrFrameBTN"
                             Margin="0"
@@ -755,7 +829,7 @@
                             ButtonText="OCR Frame"
                             Click="RefreshBTN_Click"
                             ToolTip="OCR Frame (Ctrl + R)"
-                            Visibility="Collapsed" />
+                            Visibility="Collapsed"/>
 
                         <ToggleButton
                             x:Name="FreezeToggleButton"
@@ -765,7 +839,7 @@
                             Click="FreezeToggleButton_Click"
                             Style="{StaticResource ToggleSymbolButton}"
                             ToolTip="(F) Freeze the content within Grab Frame">
-                            <ui:SymbolIcon Symbol="Pause24" />
+                            <ui:SymbolIcon Symbol="Pause24"/>
                         </ToggleButton>
 
                         <ToggleButton
@@ -776,7 +850,7 @@
                             Click="TableToggleButton_Click"
                             Style="{StaticResource ToggleSymbolButton}"
                             ToolTip="(T) Analyze content as tables">
-                            <ui:SymbolIcon Symbol="Table24" />
+                            <ui:SymbolIcon Symbol="Table24"/>
                         </ToggleButton>
 
                         <ToggleButton
@@ -787,7 +861,7 @@
                             Click="TranslateToggleButton_Click"
                             Style="{StaticResource ToggleSymbolButton}"
                             ToolTip="Enable real-time translation">
-                            <ui:SymbolIcon Symbol="LocalLanguage24" />
+                            <ui:SymbolIcon Symbol="LocalLanguage24"/>
                         </ToggleButton>
 
                         <ToggleButton
@@ -814,7 +888,7 @@
                             IsChecked="False"
                             Style="{StaticResource ToggleSymbolButton}"
                             ToolTip="(E) Edit individual words in Grab Frame">
-                            <ui:SymbolIcon Symbol="Window24" />
+                            <ui:SymbolIcon Symbol="Window24"/>
                         </ToggleButton>
 
                         <controls:CollapsibleButton
@@ -825,7 +899,18 @@
                             Click="SettingsBTN_Click"
                             IsSymbol="True"
                             ToolTip="Open Text Grab Settings"
-                            Visibility="Collapsed" />
+                            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
@@ -836,7 +921,7 @@
                         ButtonSymbol="Copy24"
                         ButtonText="Grab"
                         Command="{x:Static local:GrabFrame.GrabCommand}"
-                        ToolTip="Grab text in the Grab Frame" />
+                        ToolTip="Grab text in the Grab Frame"/>
                 </Grid>
             </Border>
         </Grid>
diff --git a/Text-Grab/Views/GrabFrame.xaml.cs b/Text-Grab/Views/GrabFrame.xaml.cs
index f9db5caa..82b4d31a 100644
--- a/Text-Grab/Views/GrabFrame.xaml.cs
+++ b/Text-Grab/Views/GrabFrame.xaml.cs
@@ -2178,6 +2178,77 @@ private void SettingsBTN_Click(object sender, RoutedEventArgs e)
         WindowUtilities.OpenOrActivateWindow<SettingsWindow>();
     }
 
+    private void SaveAsTemplate_Click(object sender, RoutedEventArgs e)
+    {
+        bool show = SaveAsTemplateBTN.IsChecked == true;
+        TemplateSavePanel.Visibility = show ? Visibility.Visible : Visibility.Collapsed;
+        if (show)
+            TemplateNameBox.Focus();
+    }
+
+    private void SaveTemplateSave_Click(object sender, RoutedEventArgs e)
+    {
+        string name = TemplateNameBox.Text.Trim();
+        if (string.IsNullOrWhiteSpace(name))
+        {
+            TemplateNameBox.Focus();
+            return;
+        }
+
+        if (wordBorders.Count == 0)
+        {
+            MessageBox.Show(
+                "Use Ctrl+drag to draw at least one region before saving.",
+                "No Regions",
+                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,
+        }).ToList();
+
+        GrabTemplate template = new(name)
+        {
+            OutputTemplate = OutputTemplateBox.Text,
+            ReferenceImageWidth = cw,
+            ReferenceImageHeight = ch,
+            Regions = regions,
+        };
+
+        GrabTemplateManager.AddOrUpdateTemplate(template);
+
+        SaveAsTemplateBTN.IsChecked = false;
+        TemplateSavePanel.Visibility = Visibility.Collapsed;
+        TemplateNameBox.Text = string.Empty;
+        OutputTemplateBox.Text = string.Empty;
+
+        MessageBox.Show(
+            $"Template \"{name}\" saved with {regions.Count} region(s).\n\nEnable it in Post-Grab Actions Settings to use it during a Fullscreen Grab.",
+            "Template Saved",
+            MessageBoxButton.OK,
+            MessageBoxImage.Information);
+    }
+
+    private void SaveTemplateCancel_Click(object sender, RoutedEventArgs e)
+    {
+        SaveAsTemplateBTN.IsChecked = false;
+        TemplateSavePanel.Visibility = Visibility.Collapsed;
+    }
+
     private void TableToggleButton_Click(object? sender = null, RoutedEventArgs? e = null)
     {
         RemoveTableLines();

From 66b78566b9f303d93753cb591039346e46580f72 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Sun, 1 Mar 2026 16:28:51 -0600
Subject: [PATCH 08/35] Enhance Grab Template editing and region visualization

- Add "Edit Grab Template" button to open templates in GrabFrame for region editing with reference image support
- Implement inline template editor for name/output template changes
- Show region index badges on template regions for clarity
- Save and load template reference images in a dedicated folder
- Improve XAML consistency, tooltips, and button labeling
- Ensure template IDs and creation dates are preserved on edit
- Update region badges dynamically as regions are modified
---
 Text-Grab/Controls/PostGrabActionEditor.xaml  | 246 +++++++++++-------
 .../Controls/PostGrabActionEditor.xaml.cs     |  71 +++++
 Text-Grab/Controls/WordBorder.xaml            |  15 ++
 Text-Grab/Controls/WordBorder.xaml.cs         |  23 ++
 Text-Grab/Utilities/GrabTemplateManager.cs    |  49 ++++
 Text-Grab/Views/GrabFrame.xaml.cs             | 118 ++++++++-
 6 files changed, 428 insertions(+), 94 deletions(-)

diff --git a/Text-Grab/Controls/PostGrabActionEditor.xaml b/Text-Grab/Controls/PostGrabActionEditor.xaml
index 9f6416f8..f061a50b 100644
--- a/Text-Grab/Controls/PostGrabActionEditor.xaml
+++ b/Text-Grab/Controls/PostGrabActionEditor.xaml
@@ -14,24 +14,23 @@
     WindowStartupLocation="CenterOwner"
     mc:Ignorable="d">
     <Window.Resources>
-        <ui:ImageIcon x:Key="TextGrabIcon"
-                      Source="/Text-Grab;component/Images/TealSelect40.png"/>
+        <ui:ImageIcon x:Key="TextGrabIcon" Source="/Text-Grab;component/Images/TealSelect40.png" />
 
         <!--  Converter to convert enum to int for ComboBox SelectedIndex  -->
-        <local:EnumToIntConverter x:Key="EnumToIntConverter"/>
+        <local:EnumToIntConverter x:Key="EnumToIntConverter" />
     </Window.Resources>
     <Grid>
         <Grid.ColumnDefinitions>
-            <ColumnDefinition Width="*"/>
-            <ColumnDefinition Width="Auto"/>
-            <ColumnDefinition Width="*"/>
+            <ColumnDefinition Width="*" />
+            <ColumnDefinition Width="Auto" />
+            <ColumnDefinition Width="*" />
         </Grid.ColumnDefinitions>
 
         <Grid.RowDefinitions>
-            <RowDefinition Height="Auto"/>
-            <RowDefinition Height="*"/>
-            <RowDefinition Height="Auto"/>
-            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto" />
         </Grid.RowDefinitions>
 
         <ui:TitleBar
@@ -40,7 +39,7 @@
             Height="32"
             Margin="2,2,2,0"
             Padding="8,2"
-            Icon="{StaticResource TextGrabIcon}"/>
+            Icon="{StaticResource TextGrabIcon}" />
 
         <!--  Available Actions (Left)  -->
         <StackPanel
@@ -51,13 +50,13 @@
                 Margin="0,0,0,8"
                 FontSize="18"
                 FontWeight="SemiBold"
-                Text="Available Actions"/>
+                Text="Available Actions" />
             <TextBlock
                 x:Name="AvailableActionsHint"
                 Margin="0,0,0,4"
                 Opacity="0.7"
                 Text="Actions that can be added to the enabled list"
-                TextWrapping="Wrap"/>
+                TextWrapping="Wrap" />
             <Border
                 Background="{ui:ThemeResource CardBackgroundFillColorSecondaryBrush}"
                 BorderBrush="{ui:ThemeResource CardStrokeColorDefaultBrush}"
@@ -72,13 +71,11 @@
                         ScrollViewer.VerticalScrollBarVisibility="Visible">
                         <ListView.View>
                             <GridView>
-                                <GridViewColumn Width="46"
-                                                Header="Icon">
+                                <GridViewColumn Width="46" Header="Icon">
                                     <GridViewColumn.CellTemplate>
                                         <DataTemplate>
                                             <Viewbox Height="24">
-                                                <ui:SymbolIcon FontSize="24"
-                                                               Symbol="{Binding Path=SymbolIcon, Mode=OneWay}"/>
+                                                <ui:SymbolIcon FontSize="24" Symbol="{Binding Path=SymbolIcon, Mode=OneWay}" />
                                             </Viewbox>
                                         </DataTemplate>
                                     </GridViewColumn.CellTemplate>
@@ -86,7 +83,7 @@
                                 <GridViewColumn
                                     Width="300"
                                     DisplayMemberBinding="{Binding ButtonText}"
-                                    Header="Action Name"/>
+                                    Header="Action Name" />
                             </GridView>
                         </ListView.View>
                     </ui:ListView>
@@ -98,7 +95,7 @@
                         FontSize="14"
                         Opacity="0.6"
                         Text="All actions are currently enabled"
-                        Visibility="Collapsed"/>
+                        Visibility="Collapsed" />
                 </Grid>
             </Border>
         </StackPanel>
@@ -117,10 +114,8 @@
                 Click="AddButton_Click"
                 ToolTip="Add selected action to enabled list">
                 <StackPanel Orientation="Horizontal">
-                    <ui:SymbolIcon FontSize="14"
-                                   Symbol="ArrowRight16"/>
-                    <TextBlock Margin="4,0,0,0"
-                               Text="Add"/>
+                    <ui:SymbolIcon FontSize="14" Symbol="ArrowRight16" />
+                    <TextBlock Margin="4,0,0,0" Text="Add" />
                 </StackPanel>
             </ui:Button>
             <ui:Button
@@ -131,13 +126,11 @@
                 Click="RemoveButton_Click"
                 ToolTip="Remove selected action from enabled list">
                 <StackPanel Orientation="Horizontal">
-                    <ui:SymbolIcon FontSize="14"
-                                   Symbol="ArrowLeft16"/>
-                    <TextBlock Margin="4,0,0,0"
-                               Text="Remove"/>
+                    <ui:SymbolIcon FontSize="14" Symbol="ArrowLeft16" />
+                    <TextBlock Margin="4,0,0,0" Text="Remove" />
                 </StackPanel>
             </ui:Button>
-            <Separator Margin="0,8"/>
+            <Separator Margin="0,8" />
             <ui:Button
                 x:Name="MoveUpButton"
                 Width="100"
@@ -146,10 +139,8 @@
                 Click="MoveUpButton_Click"
                 ToolTip="Move selected action up in order">
                 <StackPanel Orientation="Horizontal">
-                    <ui:SymbolIcon FontSize="14"
-                                   Symbol="ArrowUp16"/>
-                    <TextBlock Margin="4,0,0,0"
-                               Text="Up"/>
+                    <ui:SymbolIcon FontSize="14" Symbol="ArrowUp16" />
+                    <TextBlock Margin="4,0,0,0" Text="Up" />
                 </StackPanel>
             </ui:Button>
             <ui:Button
@@ -159,10 +150,8 @@
                 Click="MoveDownButton_Click"
                 ToolTip="Move selected action down in order">
                 <StackPanel Orientation="Horizontal">
-                    <ui:SymbolIcon FontSize="14"
-                                   Symbol="ArrowDown16"/>
-                    <TextBlock Margin="4,0,0,0"
-                               Text="Down"/>
+                    <ui:SymbolIcon FontSize="14" Symbol="ArrowDown16" />
+                    <TextBlock Margin="4,0,0,0" Text="Down" />
                 </StackPanel>
             </ui:Button>
         </StackPanel>
@@ -176,12 +165,12 @@
                 Margin="0,0,0,8"
                 FontSize="18"
                 FontWeight="SemiBold"
-                Text="Enabled Actions"/>
+                Text="Enabled Actions" />
             <TextBlock
                 Margin="0,0,0,4"
                 Opacity="0.7"
                 Text="Actions that will appear in the post-grab menu"
-                TextWrapping="Wrap"/>
+                TextWrapping="Wrap" />
             <Border
                 Background="{ui:ThemeResource CardBackgroundFillColorSecondaryBrush}"
                 BorderBrush="{ui:ThemeResource CardStrokeColorDefaultBrush}"
@@ -195,13 +184,11 @@
                     ScrollViewer.VerticalScrollBarVisibility="Visible">
                     <ListView.View>
                         <GridView>
-                            <GridViewColumn Width="46"
-                                            Header="Icon">
+                            <GridViewColumn Width="46" Header="Icon">
                                 <GridViewColumn.CellTemplate>
                                     <DataTemplate>
                                         <Viewbox Height="24">
-                                            <ui:SymbolIcon FontSize="24"
-                                                           Symbol="{Binding Path=SymbolIcon, Mode=OneWay}"/>
+                                            <ui:SymbolIcon FontSize="24" Symbol="{Binding Path=SymbolIcon, Mode=OneWay}" />
                                         </Viewbox>
                                     </DataTemplate>
                                 </GridViewColumn.CellTemplate>
@@ -209,16 +196,14 @@
                             <GridViewColumn
                                 Width="180"
                                 DisplayMemberBinding="{Binding ButtonText}"
-                                Header="Action Name"/>
-                            <GridViewColumn Width="120"
-                                            Header="Default">
+                                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 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>
@@ -233,7 +218,7 @@
                 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"/>
+                ToolTip="When enabled, the post-grab menu stays open after clicking an action, allowing multiple actions to be selected" />
         </StackPanel>
 
         <!--  Grab Templates Section  -->
@@ -242,51 +227,69 @@
             Grid.Column="0"
             Grid.ColumnSpan="3"
             Margin="16,0,16,8"
+            Background="{ui:ThemeResource CardBackgroundFillColorSecondaryBrush}"
             BorderBrush="{ui:ThemeResource CardStrokeColorDefaultBrush}"
             BorderThickness="1"
-            CornerRadius="8"
-            Background="{ui:ThemeResource CardBackgroundFillColorSecondaryBrush}">
+            CornerRadius="8">
             <Grid Margin="12,10">
                 <Grid.RowDefinitions>
-                    <RowDefinition Height="Auto"/>
-                    <RowDefinition Height="Auto"/>
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" />
                 </Grid.RowDefinitions>
 
                 <!--  Header + buttons  -->
-                <Grid Grid.Row="0"
-                      Margin="0,0,0,8">
+                <Grid Grid.Row="0" Margin="0,0,0,8">
                     <Grid.ColumnDefinitions>
-                        <ColumnDefinition Width="*"/>
-                        <ColumnDefinition Width="Auto"/>
+                        <ColumnDefinition Width="*" />
+                        <ColumnDefinition Width="Auto" />
                     </Grid.ColumnDefinitions>
 
-                    <StackPanel Grid.Column="0"
-                                VerticalAlignment="Center">
+                    <StackPanel Grid.Column="0" VerticalAlignment="Center">
                         <TextBlock
                             FontSize="16"
                             FontWeight="SemiBold"
-                            Text="Grab Templates"/>
+                            Text="Grab Templates" />
                         <TextBlock
-                            Opacity="0.7"
                             FontSize="11"
+                            Opacity="0.7"
                             Text="Templates extract structured data from fixed-layout documents. Open a Grab Frame, use Ctrl+drag to draw regions, then click the Save as Template button. Add a template to the Enabled Actions list to use it during a Fullscreen Grab."
-                            TextWrapping="Wrap"/>
+                            TextWrapping="Wrap" />
                     </StackPanel>
 
                     <StackPanel
                         Grid.Column="1"
-                        Orientation="Horizontal"
-                        VerticalAlignment="Center">
+                        VerticalAlignment="Center"
+                        Orientation="Horizontal">
                         <ui:Button
                             x:Name="OpenGrabFrameButton"
                             Margin="0,0,6,0"
                             Click="OpenGrabFrameButton_Click"
-                            ToolTip="Open a Grab Frame to draw regions and save as a template">
+                            ToolTip="Open a blank Grab Frame to draw regions and save as a new template">
+                            <StackPanel Orientation="Horizontal">
+                                <ui:SymbolIcon FontSize="14" Symbol="Window24" />
+                                <TextBlock Margin="4,0,0,0" Text="Open Grab Frame" />
+                            </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="Window24"/>
-                                <TextBlock Margin="4,0,0,0"
-                                           Text="Open Grab Frame"/>
+                                <ui:SymbolIcon FontSize="14" Symbol="Edit24" />
+                                <TextBlock Margin="4,0,0,0" Text="Edit Grab Template" />
+                            </StackPanel>
+                        </ui:Button>
+                        <ui:Button
+                            x:Name="EditTemplateButton"
+                            Margin="0,0,6,0"
+                            Click="EditTemplateButton_Click"
+                            ToolTip="Edit the selected template's name and output template"
+                            Visibility="Collapsed">
+                            <StackPanel Orientation="Horizontal">
+                                <ui:SymbolIcon FontSize="14" Symbol="Edit24" />
+                                <TextBlock Margin="4,0,0,0" Text="Edit" />
                             </StackPanel>
                         </ui:Button>
                         <ui:Button
@@ -294,10 +297,8 @@
                             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"/>
+                                <ui:SymbolIcon FontSize="14" Symbol="Delete24" />
+                                <TextBlock Margin="4,0,0,0" Text="Delete" />
                             </StackPanel>
                         </ui:Button>
                     </StackPanel>
@@ -309,32 +310,29 @@
                         x:Name="TemplatesListBox"
                         MaxHeight="140"
                         ScrollViewer.HorizontalScrollBarVisibility="Disabled"
-                        ScrollViewer.VerticalScrollBarVisibility="Auto">
+                        ScrollViewer.VerticalScrollBarVisibility="Auto"
+                        SelectionChanged="TemplatesListBox_SelectionChanged">
                         <ListView.View>
                             <GridView>
                                 <GridViewColumn
                                     Width="220"
                                     DisplayMemberBinding="{Binding Name}"
-                                    Header="Template Name"/>
-                                <GridViewColumn Width="70"
-                                                Header="Regions">
+                                    Header="Template Name" />
+                                <GridViewColumn Width="70" Header="Regions">
                                     <GridViewColumn.CellTemplate>
                                         <DataTemplate>
-                                            <TextBlock Text="{Binding Regions.Count}"
-                                                       TextAlignment="Center"/>
+                                            <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">
+                                    Header="Output Template" />
+                                <GridViewColumn Width="140" Header="Last Used">
                                     <GridViewColumn.CellTemplate>
                                         <DataTemplate>
-                                            <TextBlock Text="{Binding LastUsedDate, StringFormat={}{0:g}}"
-                                                       Opacity="0.7"/>
+                                            <TextBlock Opacity="0.7" Text="{Binding LastUsedDate, StringFormat={}{0:g}}" />
                                         </DataTemplate>
                                     </GridViewColumn.CellTemplate>
                                 </GridViewColumn>
@@ -349,8 +347,76 @@
                         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"/>
+                        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>
 
@@ -367,19 +433,19 @@
                 Margin="0,0,8,0"
                 Click="ResetButton_Click"
                 Content="Reset to Defaults"
-                ToolTip="Reset to default post-grab actions"/>
+                ToolTip="Reset to default post-grab actions" />
             <ui:Button
                 x:Name="SaveButton"
                 Margin="0,0,8,0"
                 Appearance="Primary"
                 Click="SaveButton_Click"
                 Content="Save"
-                ToolTip="Save changes and close"/>
+                ToolTip="Save changes and close" />
             <ui:Button
                 x:Name="CancelButton"
                 Click="CancelButton_Click"
                 Content="Cancel"
-                ToolTip="Close without saving"/>
+                ToolTip="Close without saving" />
         </StackPanel>
     </Grid>
 </ui:FluentWindow>
diff --git a/Text-Grab/Controls/PostGrabActionEditor.xaml.cs b/Text-Grab/Controls/PostGrabActionEditor.xaml.cs
index c82d375d..e7d0ebe2 100644
--- a/Text-Grab/Controls/PostGrabActionEditor.xaml.cs
+++ b/Text-Grab/Controls/PostGrabActionEditor.xaml.cs
@@ -38,6 +38,7 @@ public partial class PostGrabActionEditor : FluentWindow
 
     private ObservableCollection<ButtonInfo> AvailableActions { get; set; }
     private ObservableCollection<ButtonInfo> EnabledActions { get; set; }
+    private GrabTemplate? _editingTemplate;
 
     #endregion Properties
 
@@ -225,6 +226,24 @@ private void OpenGrabFrameButton_Click(object sender, RoutedEventArgs e)
         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)
@@ -268,5 +287,57 @@ private void RefreshTemplatesAndActions()
         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..b4dbda65 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
     {
diff --git a/Text-Grab/Utilities/GrabTemplateManager.cs b/Text-Grab/Utilities/GrabTemplateManager.cs
index 6f01f9f2..03d9126b 100644
--- a/Text-Grab/Utilities/GrabTemplateManager.cs
+++ b/Text-Grab/Utilities/GrabTemplateManager.cs
@@ -4,6 +4,8 @@
 using System.IO;
 using System.Linq;
 using System.Text.Json;
+using System.Text.RegularExpressions;
+using System.Windows.Media.Imaging;
 using Text_Grab.Models;
 using Text_Grab.Properties;
 using Wpf.Ui.Controls;
@@ -49,6 +51,53 @@ private static string GetTemplatesFilePath()
         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 = Regex.Replace(templateName.ToLowerInvariant(), @"[^\w]+", "-").Trim('-');
+            string shortId = templateId.Length >= 8 ? templateId[..8] : templateId;
+            string filePath = Path.Combine(folder, $"{safeName}_{shortId}.png");
+
+            PngBitmapEncoder encoder = new();
+            encoder.Frames.Add(BitmapFrame.Create(imageSource));
+            using FileStream fs = new(filePath, FileMode.Create, FileAccess.Write);
+            encoder.Save(fs);
+
+            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()
diff --git a/Text-Grab/Views/GrabFrame.xaml.cs b/Text-Grab/Views/GrabFrame.xaml.cs
index 82b4d31a..2cfaa412 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 GrabTemplate? _editingTemplate;
+    private string? _currentImagePath;
     private bool hasLoadedImageSource = false;
     private bool IsDragOver = false;
     private bool isDrawing = false;
@@ -136,6 +138,79 @@ public GrabFrame(string imagePath)
         Loaded += async (s, e) => await TryLoadImageFromPath(absolutePath);
     }
 
+    /// <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;
+        OutputTemplateBox.Text = template.OutputTemplate;
+
+        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();
+        reSearchTimer.Start();
+    }
+
     private async Task LoadContentFromHistory(HistoryInfo history)
     {
         FrameText = history.TextContent;
@@ -1435,7 +1510,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();
@@ -2071,6 +2146,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()
@@ -2184,6 +2262,8 @@ private void SaveAsTemplate_Click(object sender, RoutedEventArgs e)
         TemplateSavePanel.Visibility = show ? Visibility.Visible : Visibility.Collapsed;
         if (show)
             TemplateNameBox.Focus();
+
+        UpdateTemplateBadges();
     }
 
     private void SaveTemplateSave_Click(object sender, RoutedEventArgs e)
@@ -2211,7 +2291,7 @@ private void SaveTemplateSave_Click(object sender, RoutedEventArgs e)
         // 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
+        List<TemplateRegion> regions = [.. sorted.Select((wb, i) => new TemplateRegion
         {
             RegionNumber = i + 1,
             Label = string.IsNullOrWhiteSpace(wb.Word) ? $"Region {i + 1}" : wb.Word,
@@ -2219,7 +2299,7 @@ private void SaveTemplateSave_Click(object sender, RoutedEventArgs e)
             RatioTop = wb.Top / ch,
             RatioWidth = wb.ActualWidth / cw,
             RatioHeight = wb.ActualHeight / ch,
-        }).ToList();
+        })];
 
         GrabTemplate template = new(name)
         {
@@ -2229,12 +2309,24 @@ private void SaveTemplateSave_Click(object sender, RoutedEventArgs e)
             Regions = regions,
         };
 
+        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;
         OutputTemplateBox.Text = string.Empty;
+        UpdateTemplateBadges();
 
         MessageBox.Show(
             $"Template \"{name}\" saved with {regions.Count} region(s).\n\nEnable it in Post-Grab Actions Settings to use it during a Fullscreen Grab.",
@@ -2247,6 +2339,23 @@ 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;
+            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;
     }
 
     private void TableToggleButton_Click(object? sender = null, RoutedEventArgs? e = null)
@@ -2270,6 +2379,7 @@ private async Task TryLoadImageFromPath(string path)
             droppedImage.EndInit();
             frameContentImageSource = droppedImage;
             hasLoadedImageSource = true;
+            _currentImagePath = path;
             FreezeToggleButton.IsChecked = true;
             FreezeGrabFrame();
             FreezeToggleButton.Visibility = Visibility.Collapsed;
@@ -2485,7 +2595,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)
             return;
 
         if (e.Key == Key.Delete)

From 092bf5d219de72a364df82b56e486e42c382122e Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Sun, 1 Mar 2026 20:36:14 -0600
Subject: [PATCH 09/35] Add inline chip picker control for RichTextBox

Introduces InlinePickerRichTextBox, enabling users to insert and remove inline "chip" elements (with label and value) via a popup picker triggered by typing '{'. Includes supporting InlineChipElement and InlinePickerItem classes, plus XAML styles for a compact, modern UI. Chips are serializable to and from plain text, supporting scenarios like variable or tag insertion.
---
 Text-Grab/Controls/InlineChipElement.cs       |  48 ++
 Text-Grab/Controls/InlinePickerItem.cs        |  17 +
 Text-Grab/Controls/InlinePickerRichTextBox.cs | 566 ++++++++++++++++++
 Text-Grab/Themes/Generic.xaml                 | 122 ++++
 4 files changed, 753 insertions(+)
 create mode 100644 Text-Grab/Controls/InlineChipElement.cs
 create mode 100644 Text-Grab/Controls/InlinePickerItem.cs
 create mode 100644 Text-Grab/Controls/InlinePickerRichTextBox.cs
 create mode 100644 Text-Grab/Themes/Generic.xaml

diff --git a/Text-Grab/Controls/InlineChipElement.cs b/Text-Grab/Controls/InlineChipElement.cs
new file mode 100644
index 00000000..da12f279
--- /dev/null
+++ b/Text-Grab/Controls/InlineChipElement.cs
@@ -0,0 +1,48 @@
+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;
+
+    static InlineChipElement()
+    {
+        DefaultStyleKeyProperty.OverrideMetadata(
+            typeof(InlineChipElement),
+            new FrameworkPropertyMetadata(typeof(InlineChipElement)));
+    }
+
+    public override void OnApplyTemplate()
+    {
+        base.OnApplyTemplate();
+
+        if (GetTemplateChild(PartRemoveButton) is Button removeButton)
+            removeButton.Click += (s, 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..fc3f82d2
--- /dev/null
+++ b/Text-Grab/Controls/InlinePickerItem.cs
@@ -0,0 +1,17 @@
+namespace Text_Grab.Controls;
+
+public class InlinePickerItem
+{
+    public string DisplayName { get; set; } = string.Empty;
+    public string Value { get; set; } = string.Empty;
+
+    public InlinePickerItem() { }
+
+    public InlinePickerItem(string displayName, string value)
+    {
+        DisplayName = displayName;
+        Value = value;
+    }
+
+    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..615c455d
--- /dev/null
+++ b/Text-Grab/Controls/InlinePickerRichTextBox.cs
@@ -0,0 +1,566 @@
+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;
+
+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.
+/// </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;
+
+    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 = 120,
+            MaxHeight = 150,
+            FontSize = 11,
+            BorderThickness = new Thickness(0),
+            Background = Brushes.Transparent,
+            FocusVisualStyle = null,
+            Focusable = false,
+        };
+        lb.SetResourceReference(ForegroundProperty, "TextFillColorPrimaryBrush");
+
+        // Item template: DisplayName + muted Value label side-by-side
+        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;
+        lb.ItemTemplate = dt;
+
+        lb.PreviewMouseDown += ListBox_PreviewMouseDown;
+        lb.ItemContainerStyle = BuildCompactItemStyle();
+        return lb;
+    }
+
+    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));
+        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;
+                _listBox.SelectedIndex = (_listBox.SelectedIndex + 1) % Math.Max(1, _listBox.Items.Count);
+                _listBox.ScrollIntoView(_listBox.SelectedItem);
+                break;
+
+            case Key.Up:
+                e.Handled = true;
+                _listBox.SelectedIndex = _listBox.SelectedIndex > 0
+                    ? _listBox.SelectedIndex - 1
+                    : _listBox.Items.Count - 1;
+                _listBox.ScrollIntoView(_listBox.SelectedItem);
+                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
+
+    #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;
+
+        if (_listBox.SelectedIndex < 0 || _listBox.SelectedIndex >= filtered.Count)
+            _listBox.SelectedIndex = 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 ?? [];
+
+        return filterText.Length == 0
+            ? [.. source]
+            : [.. source.Where(i =>
+                i.DisplayName.Contains(filterText, StringComparison.OrdinalIgnoreCase) ||
+                i.Value.Contains(filterText, StringComparison.OrdinalIgnoreCase))];
+    }
+
+    #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)
+        {
+            _listBox.SelectedItem = ((ListBoxItem)hit).DataContext ?? ((ListBoxItem)hit).Content;
+            CommitSelection();
+            e.Handled = true;
+            Focus();
+        }
+    }
+
+    private void CommitSelection()
+    {
+        if (_listBox.SelectedItem is not InlinePickerItem selectedItem || _triggerStart == null)
+            return;
+
+        _isModifyingDocument = true;
+        try
+        {
+            // Delete from trigger position to current caret (removes "{" + typed filter text)
+            new TextRange(_triggerStart, CaretPosition).Text = string.Empty;
+
+            // CaretPosition is now at the insertion point (where trigger was)
+            InlineChipElement chip = new()
+            {
+                DisplayName = selectedItem.DisplayName,
+                Value = selectedItem.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, selectedItem);
+        }
+        finally
+        {
+            _isModifyingDocument = false;
+        }
+
+        UpdateSerializedText();
+        Focus();
+    }
+
+    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;
+    }
+}
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>

From 0a4df295d8393d22ac958a62b21e079ae4fb8816 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Sun, 1 Mar 2026 20:36:27 -0600
Subject: [PATCH 10/35] Add chip picker for template output editing in
 GrabFrame

Introduce InlinePickerRichTextBox for editing Grab Template output, enabling users to insert region chips via a picker UI. Hide the old plain TextBox and update all related logic to use the new control, including serialization and deserialization of template output. Ensure region chips are kept in sync with word borders, and improve file handling for template images. Also includes XAML cleanup and minor refactoring for maintainability.
---
 Text-Grab/Utilities/GrabTemplateManager.cs |  13 +-
 Text-Grab/Views/GrabFrame.xaml             | 343 ++++++++++-----------
 Text-Grab/Views/GrabFrame.xaml.cs          |  40 ++-
 3 files changed, 207 insertions(+), 189 deletions(-)

diff --git a/Text-Grab/Utilities/GrabTemplateManager.cs b/Text-Grab/Utilities/GrabTemplateManager.cs
index 03d9126b..70e99ef2 100644
--- a/Text-Grab/Utilities/GrabTemplateManager.cs
+++ b/Text-Grab/Utilities/GrabTemplateManager.cs
@@ -67,15 +67,22 @@ private static string GetTemplatesFilePath()
             if (!Directory.Exists(folder))
                 Directory.CreateDirectory(folder);
 
-            string safeName = Regex.Replace(templateName.ToLowerInvariant(), @"[^\w]+", "-").Trim('-');
+            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(filePath, FileMode.Create, FileAccess.Write);
-            encoder.Save(fs);
+            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)
diff --git a/Text-Grab/Views/GrabFrame.xaml b/Text-Grab/Views/GrabFrame.xaml
index 3eb7a778..6f64338b 100644
--- a/Text-Grab/Views/GrabFrame.xaml
+++ b/Text-Grab/Views/GrabFrame.xaml
@@ -37,21 +37,14 @@
     WindowStyle="None"
     mc:Ignorable="d">
     <Window.Resources>
-        <BitmapImage x:Key="TextGrabIcon"
-                UriSource="/Text-Grab;component/Images/TealSelect40.png"/>
+        <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 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>
 
@@ -59,31 +52,31 @@
         <CommandBinding
             CanExecute="CanPasteExecute"
             Command="{x:Static local:GrabFrame.PasteCommand}"
-            Executed="PasteExecuted"/>
+            Executed="PasteExecuted" />
         <CommandBinding
             CanExecute="CanUndoCommand"
             Command="{x:Static local:GrabFrame.UndoCommand}"
-            Executed="UndoExecuted"/>
+            Executed="UndoExecuted" />
         <CommandBinding
             CanExecute="CanRedoExecuted"
             Command="{x:Static local:GrabFrame.RedoCommand}"
-            Executed="RedoExecuted"/>
+            Executed="RedoExecuted" />
         <CommandBinding
             CanExecute="CanExecuteMergeWordBorders"
             Command="{x:Static local:GrabFrame.DeleteWordsCommand}"
-            Executed="DeleteWordBordersExecuted"/>
+            Executed="DeleteWordBordersExecuted" />
         <CommandBinding
             CanExecute="CanChangeWordBorderExecute"
             Command="{x:Static local:GrabFrame.MergeWordsCommand}"
-            Executed="MergeWordBordersExecuted"/>
+            Executed="MergeWordBordersExecuted" />
         <CommandBinding
             CanExecute="CanExecuteGrab"
             Command="{x:Static local:GrabFrame.GrabCommand}"
-            Executed="GrabExecuted"/>
+            Executed="GrabExecuted" />
         <CommandBinding
             CanExecute="CanExecuteGrab"
             Command="{x:Static local:GrabFrame.GrabTrimCommand}"
-            Executed="GrabTrimExecuted"/>
+            Executed="GrabTrimExecuted" />
     </Window.CommandBindings>
 
     <WindowChrome.WindowChrome>
@@ -91,7 +84,7 @@
             CaptionHeight="32"
             CornerRadius="18,18,2,18"
             GlassFrameThickness="0"
-            ResizeBorderThickness="5"/>
+            ResizeBorderThickness="5" />
     </WindowChrome.WindowChrome>
     <Border
         BorderBrush="{ui:ThemeResource ApplicationBackgroundBrush}"
@@ -99,10 +92,10 @@
         ClipToBounds="True">
         <Grid ClipToBounds="False">
             <Grid.RowDefinitions>
-                <RowDefinition Height="32"/>
-                <RowDefinition Height="*"/>
-                <RowDefinition Height="Auto"/>
-                <RowDefinition Height="auto"/>
+                <RowDefinition Height="32" />
+                <RowDefinition Height="*" />
+                <RowDefinition Height="Auto" />
+                <RowDefinition Height="auto" />
             </Grid.RowDefinitions>
             <Grid
                 Grid.Row="0"
@@ -110,11 +103,11 @@
                 VerticalAlignment="Top"
                 Background="{ui:ThemeResource ApplicationBackgroundBrush}">
                 <Grid.ColumnDefinitions>
-                    <ColumnDefinition Width="Auto"/>
-                    <ColumnDefinition Width="*"/>
-                    <ColumnDefinition Width="Auto"/>
-                    <ColumnDefinition Width="Auto"/>
-                    <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="*" />
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="Auto" />
                 </Grid.ColumnDefinitions>
 
                 <Menu
@@ -122,227 +115,224 @@
                     VerticalAlignment="Center"
                     ClipToBounds="True"
                     WindowChrome.IsHitTestVisibleInChrome="True">
-                    <MenuItem Header="File"
-                            SubmenuOpened="MenuItem_SubmenuOpened">
+                    <MenuItem Header="File" SubmenuOpened="MenuItem_SubmenuOpened">
                         <MenuItem
                             x:Name="AutoOcrCheckBox"
                             Click="AutoOcrCheckBox_Click"
                             Header="Auto Start OCR"
                             IsCheckable="True"
-                            IsChecked="True"/>
+                            IsChecked="True" />
                         <MenuItem
                             x:Name="AlwaysUpdateEtwCheckBox"
                             Header="Auto Update Content in Edit Text Window"
                             IsCheckable="True"
-                            IsChecked="True"/>
+                            IsChecked="True" />
                         <MenuItem
                             x:Name="ReadBarcodesMenuItem"
                             Checked="ReadBarcodesMenuItem_Checked"
                             Header="Try to read barcodes and QR Codes"
                             IsCheckable="True"
-                            Unchecked="ReadBarcodesMenuItem_Checked"/>
+                            Unchecked="ReadBarcodesMenuItem_Checked" />
                         <MenuItem
                             x:Name="IsTopmostMenuItem"
                             Header="Keep Grab Frame On Top"
                             IsCheckable="True"
-                            IsChecked="{Binding Topmost, ElementName=GrabFrameWindow, Mode=TwoWay}"/>
-                        <Separator/>
-                        <MenuItem x:Name="TranslationMenuItem"
-                                Header="Translation to...">
+                            IsChecked="{Binding Topmost, ElementName=GrabFrameWindow, Mode=TwoWay}" />
+                        <Separator />
+                        <MenuItem x:Name="TranslationMenuItem" Header="Translation to...">
                             <MenuItem
                                 x:Name="EnableTranslationMenuItem"
                                 Click="EnableTranslationMenuItem_Click"
                                 Header="Enable Real-time Translation"
-                                IsCheckable="True"/>
-                            <Separator/>
+                                IsCheckable="True" />
+                            <Separator />
                             <MenuItem Header="Target Language">
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="English"
                                     IsCheckable="True"
-                                    Tag="English"/>
+                                    Tag="English" />
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Spanish"
                                     IsCheckable="True"
-                                    Tag="Spanish"/>
+                                    Tag="Spanish" />
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="French"
                                     IsCheckable="True"
-                                    Tag="French"/>
+                                    Tag="French" />
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="German"
                                     IsCheckable="True"
-                                    Tag="German"/>
+                                    Tag="German" />
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Italian"
                                     IsCheckable="True"
-                                    Tag="Italian"/>
+                                    Tag="Italian" />
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Portuguese"
                                     IsCheckable="True"
-                                    Tag="Portuguese"/>
+                                    Tag="Portuguese" />
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Russian"
                                     IsCheckable="True"
-                                    Tag="Russian"/>
+                                    Tag="Russian" />
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Japanese"
                                     IsCheckable="True"
-                                    Tag="Japanese"/>
+                                    Tag="Japanese" />
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Chinese (Simplified)"
                                     IsCheckable="True"
-                                    Tag="Chinese (Simplified)"/>
+                                    Tag="Chinese (Simplified)" />
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Korean"
                                     IsCheckable="True"
-                                    Tag="Korean"/>
+                                    Tag="Korean" />
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Arabic"
                                     IsCheckable="True"
-                                    Tag="Arabic"/>
+                                    Tag="Arabic" />
                                 <MenuItem
                                     Click="TranslationLanguageMenuItem_Click"
                                     Header="Hindi"
                                     IsCheckable="True"
-                                    Tag="Hindi"/>
+                                    Tag="Hindi" />
                             </MenuItem>
                         </MenuItem>
-                        <Separator/>
+                        <Separator />
                         <MenuItem
                             Command="{x:Static local:GrabFrame.PasteCommand}"
                             Header="Paste Image"
-                            InputGestureText="Ctrl + Shift + V"/>
+                            InputGestureText="Ctrl + Shift + V" />
                         <MenuItem
                             Click="OpenImageMenuItem_Click"
                             Header="Open Image..."
-                            InputGestureText="Ctrl + O"/>
-                        <MenuItem x:Name="OpenRecentGrabsMenuItem"
-                                Header="Recent Grabs"/>
-                        <Separator/>
+                            InputGestureText="Ctrl + O" />
+                        <MenuItem x:Name="OpenRecentGrabsMenuItem" Header="Recent Grabs" />
+                        <Separator />
                         <MenuItem
                             Name="GrabMenuItem"
                             Command="{x:Static local:GrabFrame.GrabCommand}"
                             Header="_Grab"
-                            InputGestureText="Ctrl + G"/>
+                            InputGestureText="Ctrl + G" />
                         <MenuItem
                             Name="GrabTrimSingleMenuItem"
                             Command="{x:Static local:GrabFrame.GrabTrimCommand}"
                             Header="Grab text as Single Line"
-                            InputGestureText="Ctrl + Shift + G"/>
-                        <Separator/>
+                            InputGestureText="Ctrl + Shift + G" />
+                        <Separator />
                         <MenuItem
                             Name="SettingsMenuItem"
                             Click="SettingsBTN_Click"
-                            Header="Text Grab Settings"/>
+                            Header="Text Grab Settings" />
                         <MenuItem
                             Name="CloseMenuItem"
                             Click="OnCloseButtonClick"
                             Header="Close"
-                            InputGestureText="Alt + F4"/>
+                            InputGestureText="Alt + F4" />
                     </MenuItem>
                     <MenuItem Header="Edit">
                         <MenuItem
                             Name="RedoMenuItem"
                             Command="{x:Static local:GrabFrame.RedoCommand}"
                             Header="Redo"
-                            InputGestureText="Ctrl + Y"/>
+                            InputGestureText="Ctrl + Y" />
                         <MenuItem
                             Name="UndoMenuItem"
                             Command="{x:Static local:GrabFrame.UndoCommand}"
                             Header="Undo"
-                            InputGestureText="Ctrl + Z"/>
+                            InputGestureText="Ctrl + Z" />
                         <MenuItem
                             Name="SelectAllMenuItem"
                             Click="SelectAllWordBorders"
                             Header="Select All"
-                            InputGestureText="Ctrl + A"/>
+                            InputGestureText="Ctrl + A" />
                         <MenuItem
                             Name="AddEditOcrMenuItem"
                             Header="Add, move, or Resize lines"
                             InputGestureText="Hold Ctrl"
-                            IsCheckable="True"/>
-                        <Separator/>
+                            IsCheckable="True" />
+                        <Separator />
                         <MenuItem Header="Edit Image">
                             <MenuItem
                                 Name="InvertColorsMI"
                                 Click="InvertColorsMI_Click"
-                                Header="Invert Colors"/>
+                                Header="Invert Colors" />
                             <MenuItem
                                 Name="AutoContrastMI"
                                 Click="AutoContrastMI_Click"
-                                Header="Increase Contrast (Sigmoid)"/>
+                                Header="Increase Contrast (Sigmoid)" />
                             <MenuItem
                                 Name="BrightenMI"
                                 Click="BrightenMI_Click"
-                                Header="Brighten"/>
+                                Header="Brighten" />
                             <MenuItem
                                 Name="DarkenMI"
                                 Click="DarkenMI_Click"
-                                Header="Darken"/>
+                                Header="Darken" />
                             <MenuItem
                                 Name="GrayscaleMI"
                                 Click="GrayscaleMI_Click"
-                                Header="Grayscale"/>
+                                Header="Grayscale" />
                         </MenuItem>
                         <MenuItem
                             Click="RefreshBTN_Click"
                             Header="Refresh Grab Frame OCR Results"
-                            InputGestureText="(Ctrl + R)"/>
+                            InputGestureText="(Ctrl + R)" />
                         <MenuItem
                             Checked="AspectRationMI_Checked"
                             Header="Maintain Aspect Ratio"
                             IsCheckable="True"
                             IsChecked="{Binding IsChecked, ElementName=AspectRationMI, Mode=TwoWay}"
-                            Unchecked="AspectRationMI_Checked"/>
+                            Unchecked="AspectRationMI_Checked" />
                         <MenuItem
                             Click="FreezeToggleButton_Click"
                             Header="Freeze Image In Frame"
                             InputGestureText="F"
                             IsCheckable="True"
-                            IsChecked="{Binding IsChecked, ElementName=FreezeToggleButton, Mode=TwoWay}"/>
+                            IsChecked="{Binding IsChecked, ElementName=FreezeToggleButton, Mode=TwoWay}" />
                         <MenuItem
                             Click="TableToggleButton_Click"
                             Header="Analyze as a Table"
                             InputGestureText="T"
                             IsCheckable="True"
-                            IsChecked="{Binding IsChecked, ElementName=TableToggleButton, Mode=TwoWay}"/>
+                            IsChecked="{Binding IsChecked, ElementName=TableToggleButton, Mode=TwoWay}" />
                         <MenuItem
                             Click="EditToggleButton_Click"
                             Header="Allow recognized words to be edited"
                             IsCheckable="True"
-                            IsChecked="{Binding IsChecked, ElementName=EditToggleButton, Mode=TwoWay}"/>
+                            IsChecked="{Binding IsChecked, ElementName=EditToggleButton, Mode=TwoWay}" />
                         <MenuItem
                             Click="EditTextBTN_Click"
                             Header="Send results to an Edit Text Window"
                             InputGestureText="E"
                             IsCheckable="True"
-                            IsChecked="{Binding IsChecked, ElementName=EditTextToggleButton, Mode=TwoWay}"/>
-                        <Separator/>
+                            IsChecked="{Binding IsChecked, ElementName=EditTextToggleButton, Mode=TwoWay}" />
+                        <Separator />
                         <MenuItem
                             x:Name="InvertSelectionMenuItem"
                             Click="InvertSelection"
                             Header="Invert Selection"
-                            InputGestureText="Ctrl + I"/>
+                            InputGestureText="Ctrl + I" />
                         <MenuItem
                             Command="{x:Static local:GrabFrame.MergeWordsCommand}"
                             Header="Merge Word Borders"
-                            InputGestureText="Ctrl + M"/>
+                            InputGestureText="Ctrl + M" />
                         <MenuItem
                             Command="{x:Static local:GrabFrame.DeleteWordsCommand}"
                             Header="_Delete selected words"
-                            InputGestureText="Del"/>
-                        <Separator/>
+                            InputGestureText="Del" />
+                        <Separator />
                     </MenuItem>
                     <MenuItem Header="View">
                         <ui:MenuItem
@@ -350,43 +340,43 @@
                             Click="ScrollBehaviorMenuItem_Click"
                             Header="Scroll does nothing"
                             IsCheckable="True"
-                            Tag="None"/>
+                            Tag="None" />
                         <MenuItem
                             x:Name="ResizeScrollMenuItem"
                             Click="ScrollBehaviorMenuItem_Click"
                             Header="Scroll resizes Grab Frame"
                             IsCheckable="True"
-                            Tag="Resize"/>
+                            Tag="Resize" />
                         <MenuItem
                             x:Name="ZoomScrollMenuItem"
                             Click="ScrollBehaviorMenuItem_Click"
                             Header="Scroll Zooms Grab Frame (preview)"
                             IsCheckable="True"
-                            Tag="Zoom"/>
-                        <Separator/>
+                            Tag="Zoom" />
+                        <Separator />
                         <MenuItem
                             x:Name="CloseOnGrabMenuItem"
                             Click="CloseOnGrabMenuItem_Click"
                             Header="Close Frame on Grab"
-                            IsCheckable="True"/>
+                            IsCheckable="True" />
                     </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>
                 <StackPanel
@@ -406,10 +396,8 @@
                         <Image.Style>
                             <Style TargetType="Image">
                                 <Style.Triggers>
-                                    <DataTrigger Binding="{Binding IsActive, RelativeSource={RelativeSource AncestorType=Window}}"
-                                            Value="False">
-                                        <Setter Property="Opacity"
-                                                Value="0.6"/>
+                                    <DataTrigger Binding="{Binding IsActive, RelativeSource={RelativeSource AncestorType=Window}}" Value="False">
+                                        <Setter Property="Opacity" Value="0.6" />
                                     </DataTrigger>
                                 </Style.Triggers>
                             </Style>
@@ -424,10 +412,8 @@
                         <TextBlock.Style>
                             <Style TargetType="TextBlock">
                                 <Style.Triggers>
-                                    <DataTrigger Binding="{Binding IsActive, RelativeSource={RelativeSource AncestorType=Window}}"
-                                            Value="False">
-                                        <Setter Property="Opacity"
-                                                Value="0.6"/>
+                                    <DataTrigger Binding="{Binding IsActive, RelativeSource={RelativeSource AncestorType=Window}}" Value="False">
+                                        <Setter Property="Opacity" Value="0.6" />
                                     </DataTrigger>
                                 </Style.Triggers>
                             </Style>
@@ -442,7 +428,7 @@
                     Padding="8,2"
                     HorizontalAlignment="Right"
                     Background="{ui:ThemeResource ApplicationBackgroundBrush}"
-                    WindowChrome.IsHitTestVisibleInChrome="True"/>
+                    WindowChrome.IsHitTestVisibleInChrome="True" />
                 <StackPanel
                     Grid.Column="2"
                     Orientation="Horizontal"
@@ -454,8 +440,7 @@
                         Margin="0,-2,0,0"
                         Click="OnMinimizeButtonClick"
                         Style="{StaticResource TitleBarButtonStyle}">
-                        <TextBlock FontFamily="Segoe MDL2 Assets"
-                                Text=""/>
+                        <TextBlock FontFamily="Segoe MDL2 Assets" Text="" />
                     </Button>
                     <Button
                         x:Name="RestoreButton"
@@ -467,7 +452,7 @@
                         <TextBlock
                             x:Name="RestoreTextlock"
                             FontFamily="Segoe MDL2 Assets"
-                            Text=""/>
+                            Text="" />
                     </Button>
                     <Button
                         x:Name="CloseButton"
@@ -476,8 +461,7 @@
                         Margin="0,-2,0,0"
                         Click="OnCloseButtonClick"
                         Style="{StaticResource TitleBarCloseButtonStyle}">
-                        <TextBlock FontFamily="Segoe MDL2 Assets"
-                                Text=""/>
+                        <TextBlock FontFamily="Segoe MDL2 Assets" Text="" />
                     </Button>
 
                 </StackPanel>
@@ -487,8 +471,7 @@
                 Grid.Row="1"
                 ClipToBounds="True">
                 <Border.Background>
-                    <SolidColorBrush Opacity=".05"
-                            Color="White"/>
+                    <SolidColorBrush Opacity=".05" Color="White" />
                 </Border.Background>
                 <Grid>
                     <controls:ZoomBorder x:Name="MainZoomBorder">
@@ -500,7 +483,7 @@
                                     HorizontalAlignment="Center"
                                     VerticalAlignment="Center"
                                     Opacity="0"
-                                    Stretch="Uniform"/>
+                                    Stretch="Uniform" />
                                 <Canvas
                                     x:Name="RectanglesCanvas"
                                     Margin="-4,-2,0,0"
@@ -515,46 +498,46 @@
                                             <MenuItem
                                                 Command="{x:Static local:GrabFrame.PasteCommand}"
                                                 Header="Paste Image"
-                                                InputGestureText="Ctrl + Shift + V"/>
+                                                InputGestureText="Ctrl + Shift + V" />
                                             <MenuItem
                                                 Click="OpenImageMenuItem_Click"
                                                 Header="Open Image..."
-                                                InputGestureText="Ctrl + O"/>
-                                            <Separator/>
+                                                InputGestureText="Ctrl + O" />
+                                            <Separator />
                                             <MenuItem
                                                 x:Name="CopyText"
                                                 Click="CopyText_Click"
-                                                Header="Copy Text"/>
-                                            <Separator/>
+                                                Header="Copy Text" />
+                                            <Separator />
                                             <MenuItem
                                                 x:Name="AspectRationMI"
                                                 Checked="AspectRationMI_Checked"
                                                 Header="Maintain Aspect Ratio"
                                                 IsCheckable="True"
                                                 IsChecked="True"
-                                                Unchecked="AspectRationMI_Checked"/>
+                                                Unchecked="AspectRationMI_Checked" />
                                             <MenuItem
                                                 x:Name="FreezeMI"
                                                 Click="FreezeMI_Click"
                                                 Header="Toggle Freeze"
-                                                InputGestureText="F"/>
-                                            <Separator/>
+                                                InputGestureText="F" />
+                                            <Separator />
                                             <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
                                                 Command="{x:Static local:GrabFrame.MergeWordsCommand}"
                                                 Header="Merge Word Borders"
-                                                InputGestureText="Ctrl + M"/>
+                                                InputGestureText="Ctrl + M" />
                                             <MenuItem
                                                 Command="{x:Static local:GrabFrame.DeleteWordsCommand}"
                                                 Header="_Delete selected words"
-                                                InputGestureText="Del"/>
+                                                InputGestureText="Del" />
                                         </ContextMenu>
                                     </Canvas.ContextMenu>
                                 </Canvas>
@@ -577,21 +560,21 @@
                                 Direction="270"
                                 Opacity="0.3"
                                 ShadowDepth="2"
-                                Color="Black"/>
+                                Color="Black" />
                         </Border.Effect>
                         <Grid Margin="8,0">
                             <Grid.ColumnDefinitions>
-                                <ColumnDefinition Width="Auto"/>
-                                <ColumnDefinition Width="*"/>
-                                <ColumnDefinition Width="Auto"/>
-                                <ColumnDefinition Width="Auto"/>
+                                <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"/>
+                                Symbol="LocalLanguage24" />
                             <StackPanel
                                 Grid.Column="1"
                                 VerticalAlignment="Center"
@@ -602,13 +585,13 @@
                                     FontSize="12"
                                     FontWeight="SemiBold"
                                     Foreground="{ui:ThemeResource TextFillColorPrimaryBrush}"
-                                    Text="Translating..."/>
+                                    Text="Translating..." />
                                 <ProgressBar
                                     x:Name="TranslationProgressBar"
                                     Height="6"
                                     Maximum="100"
                                     Minimum="0"
-                                    Value="0"/>
+                                    Value="0" />
                             </StackPanel>
                             <TextBlock
                                 x:Name="TranslationCountText"
@@ -617,7 +600,7 @@
                                 VerticalAlignment="Center"
                                 FontSize="11"
                                 Foreground="{ui:ThemeResource TextFillColorSecondaryBrush}"
-                                Text="0/0"/>
+                                Text="0/0" />
                             <Button
                                 x:Name="CancelTranslationButton"
                                 Grid.Column="3"
@@ -632,7 +615,7 @@
                                 <ui:SymbolIcon
                                     FontSize="16"
                                     Foreground="{ui:ThemeResource TextFillColorSecondaryBrush}"
-                                    Symbol="Dismiss24"/>
+                                    Symbol="Dismiss24" />
                             </Button>
                         </Grid>
                     </Border>
@@ -648,64 +631,69 @@
                 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"/>
+                        <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:"/>
+                        Text="Template Name:" />
                     <TextBox
                         x:Name="TemplateNameBox"
                         Grid.Column="1"
                         Padding="4,2"
-                        VerticalContentAlignment="Center"/>
+                        VerticalContentAlignment="Center" />
                     <TextBlock
                         Grid.Column="2"
                         Margin="8,0,6,0"
                         VerticalAlignment="Center"
-                        Text="Output ({1}, {2}…):"
-                        ToolTip="Use {1}, {2}, etc. for region values. Regions are numbered left-to-right, top-to-bottom."/>
+                        Text="Output (type { to pick):"
+                        ToolTip="Type { to insert a region chip. Plain text is also supported." />
                     <TextBox
                         x:Name="OutputTemplateBox"
                         Grid.Column="3"
                         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."/>
+                        ToolTip="Use {1}, {2}, etc. for region values."
+                        Visibility="Collapsed" />
+                    <controls:InlinePickerRichTextBox
+                        x:Name="TemplateOutputBox"
+                        Grid.Column="3"
+                        VerticalAlignment="Center"
+                        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"/>
+                        Content="Save Template" />
                     <Button
                         Grid.Column="5"
                         Padding="8,4"
                         Click="SaveTemplateCancel_Click"
-                        Content="Cancel"/>
+                        Content="Cancel" />
                 </Grid>
             </Border>
 
-            <Border Grid.Row="3"
-                    Background="{ui:ThemeResource ApplicationBackgroundBrush}">
+            <Border Grid.Row="3" Background="{ui:ThemeResource ApplicationBackgroundBrush}">
                 <Grid
                     Height="30"
                     Margin="6"
                     HorizontalAlignment="Stretch"
                     VerticalAlignment="Bottom">
                     <Grid.ColumnDefinitions>
-                        <ColumnDefinition Width="auto"/>
-                        <ColumnDefinition Width="*"/>
-                        <ColumnDefinition Width="auto"/>
-                        <ColumnDefinition Width="auto"/>
-                        <ColumnDefinition Width="auto"/>
-                        <ColumnDefinition Width="110"/>
+                        <ColumnDefinition Width="auto" />
+                        <ColumnDefinition Width="*" />
+                        <ColumnDefinition Width="auto" />
+                        <ColumnDefinition Width="auto" />
+                        <ColumnDefinition Width="auto" />
+                        <ColumnDefinition Width="110" />
                     </Grid.ColumnDefinitions>
 
                     <TextBox
@@ -718,20 +706,20 @@
                         TextChanged="SearchBox_TextChanged">
                         <TextBox.ContextMenu>
                             <ContextMenu>
-                                <MenuItem Command="ApplicationCommands.Cut"/>
-                                <MenuItem Command="ApplicationCommands.Copy"/>
-                                <MenuItem Command="ApplicationCommands.Paste"/>
-                                <Separator/>
+                                <MenuItem Command="ApplicationCommands.Cut" />
+                                <MenuItem Command="ApplicationCommands.Copy" />
+                                <MenuItem Command="ApplicationCommands.Paste" />
+                                <Separator />
                                 <MenuItem
                                     x:Name="SearchWithRegexCheckBox"
                                     Click="SearchBox_GotFocus"
                                     Header="Search with Regex"
-                                    IsCheckable="True"/>
+                                    IsCheckable="True" />
                                 <MenuItem
                                     x:Name="ExactMatchChkBx"
                                     Click="SearchBox_GotFocus"
                                     Header="Match searches exactly"
-                                    IsCheckable="True"/>
+                                    IsCheckable="True" />
                             </ContextMenu>
                         </TextBox.ContextMenu>
                     </TextBox>
@@ -745,7 +733,7 @@
                         Foreground="{ui:ThemeResource TextFillColorSecondaryBrush}"
                         IsHitTestVisible="False"
                         Opacity="0.5"
-                        Visibility="{Binding Visibility, ElementName=SearchBox, Mode=OneWay}"/>
+                        Visibility="{Binding Visibility, ElementName=SearchBox, Mode=OneWay}" />
                     <controls:CollapsibleButton
                         x:Name="ClearBTN"
                         Grid.Column="1"
@@ -757,7 +745,7 @@
                         Click="ClearBTN_Click"
                         Foreground="LightGray"
                         IsSymbol="True"
-                        Visibility="Collapsed"/>
+                        Visibility="Collapsed" />
 
                     <Menu
                         x:Name="MatchesMenu"
@@ -775,15 +763,14 @@
                                     x:Name="MatchesTXTBLK"
                                     HorizontalAlignment="Left"
                                     VerticalAlignment="Center"
-                                    Text="Matches: 0"/>
+                                    Text="Matches: 0" />
                             </MenuItem.Header>
-                            <MenuItem Click="HandleDelete"
-                                    Header="Delete Selected"/>
-                            <Separator/>
+                            <MenuItem Click="HandleDelete" Header="Delete Selected" />
+                            <Separator />
                             <MenuItem
                                 Name="EditMatchesMenuItem"
                                 Click="EditMatchesMenuItem_Click"
-                                Header="Edit Selected in new Window"/>
+                                Header="Edit Selected in new Window" />
                         </MenuItem>
                     </Menu>
 
@@ -802,7 +789,7 @@
                                     VerticalAlignment="Center"
                                     FontFamily="Segoe UI"
                                     Style="{StaticResource SymbolTextStyle}"
-                                    Text="{Binding LanguageTag}"/>
+                                    Text="{Binding LanguageTag}" />
                             </DataTemplate>
                         </ComboBox.ItemTemplate>
                     </ComboBox>
@@ -821,7 +808,7 @@
                             ButtonText="Re-OCR Frame"
                             Click="RefreshBTN_Click"
                             IsSymbol="True"
-                            ToolTip="Re-OCR Frame (Ctrl + R)"/>
+                            ToolTip="Re-OCR Frame (Ctrl + R)" />
                         <controls:CollapsibleButton
                             x:Name="OcrFrameBTN"
                             Margin="0"
@@ -829,7 +816,7 @@
                             ButtonText="OCR Frame"
                             Click="RefreshBTN_Click"
                             ToolTip="OCR Frame (Ctrl + R)"
-                            Visibility="Collapsed"/>
+                            Visibility="Collapsed" />
 
                         <ToggleButton
                             x:Name="FreezeToggleButton"
@@ -839,7 +826,7 @@
                             Click="FreezeToggleButton_Click"
                             Style="{StaticResource ToggleSymbolButton}"
                             ToolTip="(F) Freeze the content within Grab Frame">
-                            <ui:SymbolIcon Symbol="Pause24"/>
+                            <ui:SymbolIcon Symbol="Pause24" />
                         </ToggleButton>
 
                         <ToggleButton
@@ -850,7 +837,7 @@
                             Click="TableToggleButton_Click"
                             Style="{StaticResource ToggleSymbolButton}"
                             ToolTip="(T) Analyze content as tables">
-                            <ui:SymbolIcon Symbol="Table24"/>
+                            <ui:SymbolIcon Symbol="Table24" />
                         </ToggleButton>
 
                         <ToggleButton
@@ -861,7 +848,7 @@
                             Click="TranslateToggleButton_Click"
                             Style="{StaticResource ToggleSymbolButton}"
                             ToolTip="Enable real-time translation">
-                            <ui:SymbolIcon Symbol="LocalLanguage24"/>
+                            <ui:SymbolIcon Symbol="LocalLanguage24" />
                         </ToggleButton>
 
                         <ToggleButton
@@ -888,7 +875,7 @@
                             IsChecked="False"
                             Style="{StaticResource ToggleSymbolButton}"
                             ToolTip="(E) Edit individual words in Grab Frame">
-                            <ui:SymbolIcon Symbol="Window24"/>
+                            <ui:SymbolIcon Symbol="Window24" />
                         </ToggleButton>
 
                         <controls:CollapsibleButton
@@ -899,7 +886,7 @@
                             Click="SettingsBTN_Click"
                             IsSymbol="True"
                             ToolTip="Open Text Grab Settings"
-                            Visibility="Collapsed"/>
+                            Visibility="Collapsed" />
 
                         <ToggleButton
                             x:Name="SaveAsTemplateBTN"
@@ -909,7 +896,7 @@
                             Click="SaveAsTemplate_Click"
                             Style="{StaticResource ToggleSymbolButton}"
                             ToolTip="Save current Ctrl+drag regions as a Grab Template">
-                            <ui:SymbolIcon Symbol="DocumentSave24"/>
+                            <ui:SymbolIcon Symbol="DocumentSave24" />
                         </ToggleButton>
                     </StackPanel>
 
@@ -921,7 +908,7 @@
                         ButtonSymbol="Copy24"
                         ButtonText="Grab"
                         Command="{x:Static local:GrabFrame.GrabCommand}"
-                        ToolTip="Grab text in the Grab Frame"/>
+                        ToolTip="Grab text in the Grab Frame" />
                 </Grid>
             </Border>
         </Grid>
diff --git a/Text-Grab/Views/GrabFrame.xaml.cs b/Text-Grab/Views/GrabFrame.xaml.cs
index 2cfaa412..c63269e8 100644
--- a/Text-Grab/Views/GrabFrame.xaml.cs
+++ b/Text-Grab/Views/GrabFrame.xaml.cs
@@ -54,7 +54,7 @@ public partial class GrabFrame : Window
     private TextBox? destinationTextBox;
     private ImageSource? frameContentImageSource;
     private HistoryInfo? historyItem;
-    private GrabTemplate? _editingTemplate;
+    private readonly GrabTemplate? _editingTemplate;
     private string? _currentImagePath;
     private bool hasLoadedImageSource = false;
     private bool IsDragOver = false;
@@ -156,7 +156,6 @@ public GrabFrame(GrabTemplate template)
     private async Task LoadTemplateForEditing(GrabTemplate template)
     {
         TemplateNameBox.Text = template.Name;
-        OutputTemplateBox.Text = template.OutputTemplate;
 
         SaveAsTemplateBTN.IsChecked = true;
         TemplateSavePanel.Visibility = Visibility.Visible;
@@ -208,6 +207,9 @@ private async Task LoadTemplateForEditing(GrabTemplate template)
 
         EnterEditMode();
         UpdateTemplateBadges();
+        UpdateTemplatePickerItems();
+        // Repopulate the output box AFTER ItemsSource is set so chips are recreated correctly
+        TemplateOutputBox.SetSerializedText(template.OutputTemplate);
         reSearchTimer.Start();
     }
 
@@ -2261,7 +2263,14 @@ 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();
     }
@@ -2303,7 +2312,7 @@ private void SaveTemplateSave_Click(object sender, RoutedEventArgs e)
 
         GrabTemplate template = new(name)
         {
-            OutputTemplate = OutputTemplateBox.Text,
+            OutputTemplate = TemplateOutputBox.GetSerializedText(),
             ReferenceImageWidth = cw,
             ReferenceImageHeight = ch,
             Regions = regions,
@@ -2325,7 +2334,7 @@ private void SaveTemplateSave_Click(object sender, RoutedEventArgs e)
         SaveAsTemplateBTN.IsChecked = false;
         TemplateSavePanel.Visibility = Visibility.Collapsed;
         TemplateNameBox.Text = string.Empty;
-        OutputTemplateBox.Text = string.Empty;
+        TemplateOutputBox.SetSerializedText(string.Empty);
         UpdateTemplateBadges();
 
         MessageBox.Show(
@@ -2356,6 +2365,20 @@ private void UpdateTemplateBadges()
         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();
+    }
+
+    private void UpdateTemplatePickerItems()
+    {
+        List<WordBorder> sorted = [.. wordBorders.OrderBy(w => w.Top).ThenBy(w => w.Left)];
+        TemplateOutputBox.ItemsSource = sorted
+            .Select((wb, i) =>
+            {
+                string label = string.IsNullOrWhiteSpace(wb.Word) ? $"Region {i + 1}" : wb.Word;
+                return new InlinePickerItem(label, $"{{{i + 1}}}");
+            })
+            .ToList();
     }
 
     private void TableToggleButton_Click(object? sender = null, RoutedEventArgs? e = null)
@@ -2372,9 +2395,10 @@ private async Task TryLoadImageFromPath(string path)
             ResetGrabFrame();
             await Task.Delay(300);
             BitmapImage droppedImage = new();
-            droppedImage.BeginInit();
-            droppedImage.UriSource = fileURI;
-            System.Drawing.RotateFlipType rotateFlipType = ImageMethods.GetRotateFlipType(path);
+                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;
@@ -2595,7 +2619,7 @@ private void Window_PreviewKeyDown(object sender, KeyEventArgs e)
         if (IsCtrlDown)
             RectanglesCanvas.Cursor = Cursors.Cross;
 
-        if (IsEditingAnyWordBorders || Keyboard.FocusedElement is TextBox)
+        if (IsEditingAnyWordBorders || Keyboard.FocusedElement is TextBox or RichTextBox)
             return;
 
         if (e.Key == Key.Delete)

From 64875dfa0256a6f31fa88d1f2a81b5bdcfe87a42 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Sun, 1 Mar 2026 20:50:52 -0600
Subject: [PATCH 11/35] Remove unused OutputTemplateBox; enhance
 TemplateOutputBox

Removed the hidden OutputTemplateBox TextBox from the UI. Updated TemplateOutputBox (InlinePickerRichTextBox) to support multi-line and tab input, and clarified its tooltip.
---
 Text-Grab/Views/GrabFrame.xaml | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/Text-Grab/Views/GrabFrame.xaml b/Text-Grab/Views/GrabFrame.xaml
index 6f64338b..ec49cd0e 100644
--- a/Text-Grab/Views/GrabFrame.xaml
+++ b/Text-Grab/Views/GrabFrame.xaml
@@ -654,18 +654,12 @@
                         VerticalAlignment="Center"
                         Text="Output (type { to pick):"
                         ToolTip="Type { to insert a region chip. Plain text is also supported." />
-                    <TextBox
-                        x:Name="OutputTemplateBox"
-                        Grid.Column="3"
-                        Padding="4,2"
-                        VerticalContentAlignment="Center"
-                        FontFamily="Consolas"
-                        ToolTip="Use {1}, {2}, etc. for region values."
-                        Visibility="Collapsed" />
                     <controls:InlinePickerRichTextBox
                         x:Name="TemplateOutputBox"
                         Grid.Column="3"
                         VerticalAlignment="Center"
+                        AcceptsReturn="True"
+                        AcceptsTab="True"
                         ToolTip="Type { to open the region picker. Plain text also supported." />
                     <Button
                         Grid.Column="4"

From dc563f3d83af3552bc5f97696e3e525c9e2fc127 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Sun, 1 Mar 2026 21:11:05 -0600
Subject: [PATCH 12/35] Update packages

---
 Tests/Tests.csproj         |  6 +++---
 Text-Grab/Text-Grab.csproj | 17 ++++++++---------
 2 files changed, 11 insertions(+), 12 deletions(-)

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/Text-Grab/Text-Grab.csproj b/Text-Grab/Text-Grab.csproj
index 0fe29466..4c1bf1c7 100644
--- a/Text-Grab/Text-Grab.csproj
+++ b/Text-Grab/Text-Grab.csproj
@@ -52,17 +52,16 @@
 
     <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="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" />

From d4b1101180b45e7df0afdf46de175d9f87ff85bf Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Sun, 1 Mar 2026 21:11:35 -0600
Subject: [PATCH 13/35] Code style

---
 Tests/GrabTemplateManagerTests.cs             |   2 -
 Text-Grab/Controls/InlinePickerRichTextBox.cs |  10 +-
 Text-Grab/Utilities/GrabTemplateManager.cs    |   1 -
 Text-Grab/Views/EditTextWindow.xaml           | 477 ++++++++----------
 Text-Grab/Views/GrabFrame.xaml.cs             |  13 +-
 5 files changed, 235 insertions(+), 268 deletions(-)

diff --git a/Tests/GrabTemplateManagerTests.cs b/Tests/GrabTemplateManagerTests.cs
index e99d92fd..c4d93e36 100644
--- a/Tests/GrabTemplateManagerTests.cs
+++ b/Tests/GrabTemplateManagerTests.cs
@@ -1,6 +1,4 @@
-using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using Text_Grab.Models;
 using Text_Grab.Utilities;
 
diff --git a/Text-Grab/Controls/InlinePickerRichTextBox.cs b/Text-Grab/Controls/InlinePickerRichTextBox.cs
index 615c455d..c07a3208 100644
--- a/Text-Grab/Controls/InlinePickerRichTextBox.cs
+++ b/Text-Grab/Controls/InlinePickerRichTextBox.cs
@@ -164,8 +164,10 @@ 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));
-        border.Name = "Bd";
+        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));
@@ -356,9 +358,9 @@ private void ListBox_PreviewMouseDown(object sender, MouseButtonEventArgs e)
         while (hit is not null and not ListBoxItem)
             hit = VisualTreeHelper.GetParent(hit);
 
-        if (hit is ListBoxItem)
+        if (hit is ListBoxItem item)
         {
-            _listBox.SelectedItem = ((ListBoxItem)hit).DataContext ?? ((ListBoxItem)hit).Content;
+            _listBox.SelectedItem = item.DataContext ?? item.Content;
             CommitSelection();
             e.Handled = true;
             Focus();
diff --git a/Text-Grab/Utilities/GrabTemplateManager.cs b/Text-Grab/Utilities/GrabTemplateManager.cs
index 70e99ef2..2c45ad8d 100644
--- a/Text-Grab/Utilities/GrabTemplateManager.cs
+++ b/Text-Grab/Utilities/GrabTemplateManager.cs
@@ -4,7 +4,6 @@
 using System.IO;
 using System.Linq;
 using System.Text.Json;
-using System.Text.RegularExpressions;
 using System.Windows.Media.Imaging;
 using Text_Grab.Models;
 using Text_Grab.Properties;
diff --git a/Text-Grab/Views/EditTextWindow.xaml b/Text-Grab/Views/EditTextWindow.xaml
index e42947e9..93200beb 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,70 @@
                         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" />
+                    <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 +517,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 +595,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 +623,7 @@
                 Style="{DynamicResource TextBoxStyle2}"
                 TextChanged="PassedTextControl_TextChanged"
                 TextWrapping="WrapWithOverflow"
-                VerticalScrollBarVisibility="Auto"/>
+                VerticalScrollBarVisibility="Auto" />
             <TextBox
                 x:Name="CalcResultsTextControl"
                 Grid.Column="1"
@@ -655,41 +641,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 +698,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 +730,7 @@
                         x:Name="CalcAggregateStatusText"
                         FontSize="12"
                         Foreground="{DynamicResource TextFillColorSecondaryBrush}"
-                        Text=""/>
+                        Text="" />
                     <ui:SymbolIcon
                         x:Name="CalcAggregateCopyIcon"
                         HorizontalAlignment="Center"
@@ -755,7 +738,7 @@
                         FontSize="16"
                         Foreground="{DynamicResource TextFillColorPrimaryBrush}"
                         Opacity="0"
-                        Symbol="Copy24"/>
+                        Symbol="Copy24" />
                 </Grid>
             </Border>
 
@@ -775,8 +758,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 +769,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 +791,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 +847,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 +875,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 +887,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 +908,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 +934,7 @@
                         <TextBlock
                             FontFamily="Cascadia Mono"
                             FontSize="12"
-                            Text="0 matches"/>
+                            Text="0 matches" />
                     </Button>
                     <Button
                         x:Name="SimilarMatchesButton"
@@ -980,17 +951,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 +980,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 +1008,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 +1028,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 +1049,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/GrabFrame.xaml.cs b/Text-Grab/Views/GrabFrame.xaml.cs
index c63269e8..f2ab0375 100644
--- a/Text-Grab/Views/GrabFrame.xaml.cs
+++ b/Text-Grab/Views/GrabFrame.xaml.cs
@@ -2372,13 +2372,12 @@ private void UpdateTemplateBadges()
     private void UpdateTemplatePickerItems()
     {
         List<WordBorder> sorted = [.. wordBorders.OrderBy(w => w.Top).ThenBy(w => w.Left)];
-        TemplateOutputBox.ItemsSource = sorted
+        TemplateOutputBox.ItemsSource = [.. sorted
             .Select((wb, i) =>
             {
                 string label = string.IsNullOrWhiteSpace(wb.Word) ? $"Region {i + 1}" : wb.Word;
                 return new InlinePickerItem(label, $"{{{i + 1}}}");
-            })
-            .ToList();
+            })];
     }
 
     private void TableToggleButton_Click(object? sender = null, RoutedEventArgs? e = null)
@@ -2395,10 +2394,10 @@ private async Task TryLoadImageFromPath(string path)
             ResetGrabFrame();
             await Task.Delay(300);
             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);
+            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;

From 44116597d2ec18329839a818a6ad918a4b95a360 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Sun, 1 Mar 2026 21:23:00 -0600
Subject: [PATCH 14/35] Add Microsoft.WindowsAppSDK.WinUI package reference

Added Microsoft.WindowsAppSDK.WinUI version 1.8.260204000 to the project file to enable or support WinUI features. No other changes were made.
---
 Text-Grab/Text-Grab.csproj | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Text-Grab/Text-Grab.csproj b/Text-Grab/Text-Grab.csproj
index 4c1bf1c7..23ed5387 100644
--- a/Text-Grab/Text-Grab.csproj
+++ b/Text-Grab/Text-Grab.csproj
@@ -61,6 +61,7 @@
         <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" />

From 7c8c8918edc1b9c6e3b5e316bd238a56d92d35fa Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Sun, 1 Mar 2026 23:55:56 -0600
Subject: [PATCH 15/35] Improve GrabFrame content area calculation and DPI
 accuracy

Refactor content area and image rect calculations to use WPF's layout engine and PointToScreen, eliminating hardcoded offsets and improving accuracy across DPI settings. Update border and resize settings for better appearance and usability. These changes ensure robust, layout-independent screen coordinate handling.
---
 Text-Grab/Utilities/ImageMethods.cs | 16 +++++-----
 Text-Grab/Views/GrabFrame.xaml      |  6 ++--
 Text-Grab/Views/GrabFrame.xaml.cs   | 46 ++++++++++++++++++++---------
 3 files changed, 43 insertions(+), 25 deletions(-)

diff --git a/Text-Grab/Utilities/ImageMethods.cs b/Text-Grab/Utilities/ImageMethods.cs
index ae43afd5..e4a908c0 100644
--- a/Text-Grab/Utilities/ImageMethods.cs
+++ b/Text-Grab/Utilities/ImageMethods.cs
@@ -117,16 +117,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
             {
diff --git a/Text-Grab/Views/GrabFrame.xaml b/Text-Grab/Views/GrabFrame.xaml
index ec49cd0e..19f3a283 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"
@@ -84,7 +84,7 @@
             CaptionHeight="32"
             CornerRadius="18,18,2,18"
             GlassFrameThickness="0"
-            ResizeBorderThickness="5" />
+            ResizeBorderThickness="8" />
     </WindowChrome.WindowChrome>
     <Border
         BorderBrush="{ui:ThemeResource ApplicationBackgroundBrush}"
diff --git a/Text-Grab/Views/GrabFrame.xaml.cs b/Text-Grab/Views/GrabFrame.xaml.cs
index f2ab0375..4b9b8a4c 100644
--- a/Text-Grab/Views/GrabFrame.xaml.cs
+++ b/Text-Grab/Views/GrabFrame.xaml.cs
@@ -285,6 +285,23 @@ private async Task LoadContentFromHistory(HistoryInfo history)
         UpdateFrameText();
     }
 
+    /// <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()
     {
         // This is a WIP to try to remove the gray letterboxes on either
@@ -1070,31 +1087,32 @@ 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;
+        double contentWidth = RectanglesCanvas.RenderSize.Width;
+        double contentHeight = RectanglesCanvas.RenderSize.Height;
 
-        if (ContentWidth == 4 || ContentHeight == 2)
+        // When the canvas hasn't been measured yet (Viewbox content is still
+        // at its minimum size), fall back to the containing border's dimensions.
+        if (contentWidth <= 4 || contentHeight <= 2)
         {
-            ContentWidth = RectanglesBorder.RenderSize.Width;
-            ContentHeight = RectanglesBorder.RenderSize.Height;
-            rectanglesPosition = new(-2, 32);
+            contentWidth = RectanglesBorder.ActualWidth;
+            contentHeight = RectanglesBorder.ActualHeight;
+            canvasScale = 1;
         }
 
+        // PointToScreen gives the exact physical-pixel origin of the canvas
+        // regardless of border thickness, DPI, or layout changes.
+        Point scanTopLeft = RectanglesCanvas.PointToScreen(new Point(0, 0));
         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)
+            X = (int)scanTopLeft.X,
+            Y = (int)scanTopLeft.Y,
+            Width = (int)(contentWidth * dpi.DpiScaleX * canvasScale),
+            Height = (int)(contentHeight * dpi.DpiScaleY * canvasScale),
         };
 
         if (ocrResultOfWindow is null || ocrResultOfWindow.Lines.Length == 0)

From 3cd300126aaa988b343499266cf1e27a040e6f7e Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Mon, 2 Mar 2026 20:02:43 -0600
Subject: [PATCH 16/35] Improve GrabFrame overlay scaling and image cropping
 accuracy

- Fix Viewbox scaling to use both width and height (Uniform)
- Crop frozen image to selection for GrabFrame continuity
- Add GrabFrame constructor for pre-loaded cropped images
- Explicitly size overlay canvas to match image pixels
- Rescale word borders from history for accurate overlays
- Refine content/non-content area calculations for sizing
- Improve background color sampling for word borders
- Add robustness checks for invalid/unmeasured sizes
- Slightly increase GrabFrame title bar height for UI polish

These changes resolve overlay misalignment and scaling issues,
ensuring accurate OCR word border placement and a consistent
user experience when grabbing, freezing, and editing regions.
---
 Text-Grab/Extensions/ControlExtensions.cs |  27 +-
 Text-Grab/Views/FullscreenGrab.xaml       |   4 +-
 Text-Grab/Views/FullscreenGrab.xaml.cs    |  34 ++-
 Text-Grab/Views/GrabFrame.xaml            |   2 +-
 Text-Grab/Views/GrabFrame.xaml.cs         | 316 ++++++++++++++++++----
 5 files changed, 315 insertions(+), 68 deletions(-)

diff --git a/Text-Grab/Extensions/ControlExtensions.cs b/Text-Grab/Extensions/ControlExtensions.cs
index 7ccfe990..4e3a32ab 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;
 
@@ -14,9 +15,33 @@ public static double GetHorizontalScaleFactor(this Viewbox viewbox)
             return 1.0;
 
         double outsideWidth = viewbox.ActualWidth;
+        double outsideHeight = viewbox.ActualHeight;
         double insideWidth = childElement.ActualWidth;
+        double insideHeight = childElement.ActualHeight;
 
-        return outsideWidth / insideWidth;
+        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 scale;
     }
 
     public static Rect GetAbsolutePlacement(this FrameworkElement element, bool relativeToScreen = false)
diff --git a/Text-Grab/Views/FullscreenGrab.xaml b/Text-Grab/Views/FullscreenGrab.xaml
index e6fedeb3..231ddc76 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml
+++ b/Text-Grab/Views/FullscreenGrab.xaml
@@ -112,9 +112,7 @@
                 </ContextMenu>
             </Canvas.ContextMenu>
         </Canvas>
-        <Canvas
-            x:Name="TemplateOverlayHost"
-            IsHitTestVisible="False" />
+        <Canvas x:Name="TemplateOverlayHost" IsHitTestVisible="False" />
         <Border
             x:Name="TopButtonsStackPanel"
             Margin="12"
diff --git a/Text-Grab/Views/FullscreenGrab.xaml.cs b/Text-Grab/Views/FullscreenGrab.xaml.cs
index a9a15a67..2223713a 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml.cs
+++ b/Text-Grab/Views/FullscreenGrab.xaml.cs
@@ -667,15 +667,35 @@ 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
+        // 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)
+        {
+            Matrix m = PresentationSource.FromVisual(this).CompositionTarget.TransformToDevice;
+            int cropX = Math.Max(0, (int)(Canvas.GetLeft(selectBorder) * m.M11));
+            int cropY = Math.Max(0, (int)(Canvas.GetTop(selectBorder) * m.M22));
+            int cropW = Math.Min((int)(selectBorder.Width * m.M11), backgroundBitmap.PixelWidth - cropX);
+            int cropH = Math.Min((int)(selectBorder.Height * m.M22), backgroundBitmap.PixelHeight - cropY);
 
-        GrabFrame grabFrame = new()
+            if (cropW > 0 && cropH > 0)
+            {
+                CroppedBitmap croppedBitmap = new(backgroundBitmap, new Int32Rect(cropX, cropY, cropW, cropH));
+                croppedBitmap.Freeze();
+                grabFrame = new GrabFrame(croppedBitmap);
+            }
+            else
+            {
+                grabFrame = new GrabFrame();
+            }
+        }
+        else
         {
-            Left = posLeft,
-            Top = posTop,
-        };
+            grabFrame = new GrabFrame();
+        }
+
+        grabFrame.Left = posLeft;
+        grabFrame.Top = posTop;
 
         grabFrame.Left -= (2 / dpi.PixelsPerDip);
         grabFrame.Top -= (48 / dpi.PixelsPerDip);
diff --git a/Text-Grab/Views/GrabFrame.xaml b/Text-Grab/Views/GrabFrame.xaml
index 19f3a283..2ec53219 100644
--- a/Text-Grab/Views/GrabFrame.xaml
+++ b/Text-Grab/Views/GrabFrame.xaml
@@ -92,7 +92,7 @@
         ClipToBounds="True">
         <Grid ClipToBounds="False">
             <Grid.RowDefinitions>
-                <RowDefinition Height="32" />
+                <RowDefinition Height="34" />
                 <RowDefinition Height="*" />
                 <RowDefinition Height="Auto" />
                 <RowDefinition Height="auto" />
diff --git a/Text-Grab/Views/GrabFrame.xaml.cs b/Text-Grab/Views/GrabFrame.xaml.cs
index 4b9b8a4c..6f6bcad6 100644
--- a/Text-Grab/Views/GrabFrame.xaml.cs
+++ b/Text-Grab/Views/GrabFrame.xaml.cs
@@ -138,6 +138,27 @@ 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>
@@ -231,11 +252,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))
@@ -243,6 +283,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)
@@ -263,26 +305,95 @@ 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>
@@ -307,17 +418,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()
@@ -1088,33 +1203,14 @@ private async Task DrawRectanglesAroundWords(string searchWord = "")
         wordBorders.Clear();
 
         DpiScale dpi = VisualTreeHelper.GetDpi(this);
-        double canvasScale = CanvasViewBox.GetHorizontalScaleFactor();
-        if (double.IsNaN(canvasScale))
-            canvasScale = 1;
-
-        double contentWidth = RectanglesCanvas.RenderSize.Width;
-        double contentHeight = RectanglesCanvas.RenderSize.Height;
-
-        // When the canvas hasn't been measured yet (Viewbox content is still
-        // at its minimum size), fall back to the containing border's dimensions.
-        if (contentWidth <= 4 || contentHeight <= 2)
+        System.Drawing.Rectangle rectCanvasSize = GetContentAreaScreenRect();
+        if (rectCanvasSize.Width <= 0 || rectCanvasSize.Height <= 0)
         {
-            contentWidth = RectanglesBorder.ActualWidth;
-            contentHeight = RectanglesBorder.ActualHeight;
-            canvasScale = 1;
+            isDrawing = false;
+            reDrawTimer.Start();
+            return;
         }
 
-        // PointToScreen gives the exact physical-pixel origin of the canvas
-        // regardless of border thickness, DPI, or layout changes.
-        Point scanTopLeft = RectanglesCanvas.PointToScreen(new Point(0, 0));
-        System.Drawing.Rectangle rectCanvasSize = new()
-        {
-            X = (int)scanTopLeft.X,
-            Y = (int)scanTopLeft.Y,
-            Width = (int)(contentWidth * dpi.DpiScaleX * canvasScale),
-            Height = (int)(contentHeight * dpi.DpiScaleY * canvasScale),
-        };
-
         if (ocrResultOfWindow is null || ocrResultOfWindow.Lines.Length == 0)
         {
             ILanguage lang = CurrentLanguage ?? LanguageUtilities.GetCurrentInputLanguage();
@@ -1126,13 +1222,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)
         {
@@ -1145,7 +1250,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();
 
@@ -1159,8 +1264,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,
@@ -1203,7 +1308,8 @@ private async Task DrawRectanglesAroundWords(string searchWord = "")
 
         isDrawing = false;
 
-        bmp?.Dispose();
+        if (shouldDisposeBmp)
+            bmp?.Dispose();
         reSearchTimer.Start();
 
         // Trigger translation if enabled
@@ -1335,6 +1441,8 @@ private void FreezeGrabFrame()
             GrabFrameImage.Source = frameContentImageSource;
         }
 
+        SyncRectanglesCanvasSizeToImage();
+
         FreezeToggleButton.IsChecked = true;
         Topmost = false;
         Background = new SolidColorBrush(Colors.DimGray);
@@ -1342,6 +1450,28 @@ private void FreezeGrabFrame()
         IsFreezeMode = true;
     }
 
+    private void SyncRectanglesCanvasSizeToImage()
+    {
+        if (GrabFrameImage.Source is not BitmapSource source)
+            return;
+
+        // Keep image and overlay in the same coordinate space (raw image pixels).
+        double sourceWidth = source.PixelWidth > 0 ? source.PixelWidth : source.Width;
+        double sourceHeight = source.PixelHeight > 0 ? source.PixelHeight : 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)
@@ -1371,6 +1501,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);
@@ -1385,10 +1563,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);
@@ -2018,6 +2212,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();
@@ -2177,6 +2377,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;
 

From bfe084bc1af0fe803ae003011fc5f9a9c3ec5541 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Tue, 3 Mar 2026 19:53:58 -0600
Subject: [PATCH 17/35] Highlight unused template regions in GrabFrame/preview

Add visual dimming for template regions not referenced in the output template, both in the GrabFrame editor and FullscreenGrab preview. WordBorder controls now support a dimmed border state, and region highlighting updates dynamically as the template is edited. Also includes minor XAML cleanup for menu item formatting. This improves clarity when editing templates by making unused regions visually distinct.
---
 Text-Grab/Controls/NotifyIconWindow.xaml  |  4 ++--
 Text-Grab/Controls/WordBorder.xaml.cs     | 23 ++++++++++++++++++-
 Text-Grab/Extensions/ControlExtensions.cs |  3 ---
 Text-Grab/Views/FullscreenGrab.xaml.cs    |  6 ++++-
 Text-Grab/Views/GrabFrame.xaml            |  1 +
 Text-Grab/Views/GrabFrame.xaml.cs         | 28 +++++++++++++++++++++++
 6 files changed, 58 insertions(+), 7 deletions(-)

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/WordBorder.xaml.cs b/Text-Grab/Controls/WordBorder.xaml.cs
index b4dbda65..ec86d291 100644
--- a/Text-Grab/Controls/WordBorder.xaml.cs
+++ b/Text-Grab/Controls/WordBorder.xaml.cs
@@ -174,7 +174,28 @@ public string Word
     public void Deselect()
     {
         IsSelected = false;
-        WordBorderBorder.BorderBrush = new SolidColorBrush(Color.FromArgb(255, 48, 142, 152));
+        ApplyTemplateDimBorderBrush();
+    }
+
+    private bool _isDimmedForTemplate = false;
+
+    /// <summary>
+    /// Dims the border brush to indicate this region is not referenced in the output template.
+    /// Call with false to restore the normal border color.
+    /// </summary>
+    public void SetDimmedForTemplate(bool isDimmed)
+    {
+        _isDimmedForTemplate = isDimmed;
+        if (!IsSelected)
+            ApplyTemplateDimBorderBrush();
+    }
+
+    private void ApplyTemplateDimBorderBrush()
+    {
+        byte alpha = _isDimmedForTemplate ? (byte)80 : (byte)255;
+        SolidColorBrush brush = new(Color.FromArgb(alpha, 48, 142, 152));
+        WordBorderBorder.BorderBrush = brush;
+        MoveResizeBorder.BorderBrush = brush;
     }
 
     public void EnterEdit()
diff --git a/Text-Grab/Extensions/ControlExtensions.cs b/Text-Grab/Extensions/ControlExtensions.cs
index 4e3a32ab..7174705d 100644
--- a/Text-Grab/Extensions/ControlExtensions.cs
+++ b/Text-Grab/Extensions/ControlExtensions.cs
@@ -6,9 +6,6 @@ namespace Text_Grab;
 
 public static class ControlExtensions
 {
-
-
-
     public static double GetHorizontalScaleFactor(this Viewbox viewbox)
     {
         if (viewbox.Child is not FrameworkElement childElement)
diff --git a/Text-Grab/Views/FullscreenGrab.xaml.cs b/Text-Grab/Views/FullscreenGrab.xaml.cs
index 2223713a..48ea0907 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml.cs
+++ b/Text-Grab/Views/FullscreenGrab.xaml.cs
@@ -426,6 +426,9 @@ private void UpdateTemplateRegionOverlays(double selLeft, double selTop, double
         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);
+
+        HashSet<int> referencedRegions = [.. template.GetReferencedRegionNumbers()];
 
         foreach (TemplateRegion region in template.Regions)
         {
@@ -437,11 +440,12 @@ private void UpdateTemplateRegionOverlays(double selLeft, double selTop, double
             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(borderColor),
+                BorderBrush = new SolidColorBrush(isReferenced ? borderColor : dimBorderColor),
                 BorderThickness = new Thickness(1.5),
             };
 
diff --git a/Text-Grab/Views/GrabFrame.xaml b/Text-Grab/Views/GrabFrame.xaml
index 2ec53219..a61972c6 100644
--- a/Text-Grab/Views/GrabFrame.xaml
+++ b/Text-Grab/Views/GrabFrame.xaml
@@ -660,6 +660,7 @@
                         VerticalAlignment="Center"
                         AcceptsReturn="True"
                         AcceptsTab="True"
+                        TextChanged="TemplateOutputBox_TextChanged"
                         ToolTip="Type { to open the region picker. Plain text also supported." />
                     <Button
                         Grid.Column="4"
diff --git a/Text-Grab/Views/GrabFrame.xaml.cs b/Text-Grab/Views/GrabFrame.xaml.cs
index 6f6bcad6..e2e031b9 100644
--- a/Text-Grab/Views/GrabFrame.xaml.cs
+++ b/Text-Grab/Views/GrabFrame.xaml.cs
@@ -2580,7 +2580,11 @@ private void UpdateTemplateBadges()
         if (!isTemplateMode)
         {
             foreach (WordBorder wb in wordBorders)
+            {
                 wb.TemplateIndex = 0;
+                wb.Opacity = 1.0;
+                wb.SetDimmedForTemplate(false);
+            }
             return;
         }
 
@@ -2589,6 +2593,30 @@ private void UpdateTemplateBadges()
             sorted[i].TemplateIndex = i + 1;
 
         UpdateTemplatePickerItems();
+        UpdateTemplateRegionOpacities();
+    }
+
+    private void UpdateTemplateRegionOpacities()
+    {
+        if (SaveAsTemplateBTN.IsChecked != true)
+            return;
+
+        string outputTemplate = TemplateOutputBox.GetSerializedText();
+        HashSet<int> referenced = [.. Regex.Matches(outputTemplate, @"\{(\d+)(?::[a-z]+)?\}")
+            .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 = isReferenced ? 1.0 : 0.5;
+            wb.SetDimmedForTemplate(!isReferenced);
+        }
+    }
+
+    private void TemplateOutputBox_TextChanged(object sender, TextChangedEventArgs e)
+    {
+        UpdateTemplateRegionOpacities();
     }
 
     private void UpdateTemplatePickerItems()

From cdca429792fa71f72be46d8d86492d124ae39549 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Tue, 3 Mar 2026 21:06:28 -0600
Subject: [PATCH 18/35] Add Grab Template support to lookup and grab workflows

Introduce "Grab Template" as a new LookupItemKind and post-grab action. Add TemplateId to LookupItem and update icon mapping. Overload LaunchFullScreenGrab to allow preselecting a template. Update FullscreenGrab to auto-check or add preselected templates in the context menu, and rename the edit menu item. Add "Manage Grab Templates..." to EditTextWindow and GrabFrame. In QuickSimpleLookup, display templates, allow Ctrl+click to edit, and Enter to launch a grab with the template. Integrate templates throughout lookup, grab, and post-processing flows.
---
 Text-Grab/Models/LookupItem.cs            |  4 ++
 Text-Grab/Utilities/WindowUtilities.cs    |  6 +++
 Text-Grab/Views/EditTextWindow.xaml       |  4 ++
 Text-Grab/Views/EditTextWindow.xaml.cs    |  6 +++
 Text-Grab/Views/FullscreenGrab.xaml.cs    | 52 +++++++++++++++++++++--
 Text-Grab/Views/GrabFrame.xaml            |  4 ++
 Text-Grab/Views/GrabFrame.xaml.cs         |  6 +++
 Text-Grab/Views/QuickSimpleLookup.xaml.cs | 38 +++++++++++++++++
 8 files changed, 117 insertions(+), 3 deletions(-)

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/Utilities/WindowUtilities.cs b/Text-Grab/Utilities/WindowUtilities.cs
index 8f7e9a3a..b0a20563 100644
--- a/Text-Grab/Utilities/WindowUtilities.cs
+++ b/Text-Grab/Utilities/WindowUtilities.cs
@@ -77,6 +77,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;
@@ -107,6 +112,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();
diff --git a/Text-Grab/Views/EditTextWindow.xaml b/Text-Grab/Views/EditTextWindow.xaml
index 93200beb..3b25d90d 100644
--- a/Text-Grab/Views/EditTextWindow.xaml
+++ b/Text-Grab/Views/EditTextWindow.xaml
@@ -457,6 +457,10 @@
                         Click="GrabFrameMenuItem_Click"
                         Header="New _Grab Frame"
                         InputGestureText="Ctrl + G" />
+                    <MenuItem
+                        x:Name="ManageGrabTemplatesMenuItem"
+                        Click="ManageGrabTemplates_Click"
+                        Header="Manage Grab _Templates..." />
                     <Separator />
                     <MenuItem
                         x:Name="QuickSimpleLookupMenuItem"
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.xaml.cs b/Text-Grab/Views/FullscreenGrab.xaml.cs
index 48ea0907..64630178 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml.cs
+++ b/Text-Grab/Views/FullscreenGrab.xaml.cs
@@ -89,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
@@ -282,12 +283,17 @@ private void LoadDynamicPostGrabActions()
         int index = 1;
         foreach (ButtonInfo action in enabledActions)
         {
+            // When a template is preselected, don't restore saved check state for other templates
+            bool isChecked = !string.IsNullOrEmpty(PreselectedTemplateId) && !string.IsNullOrEmpty(action.TemplateId)
+                ? false
+                : PostGrabActionManager.GetCheckState(action);
+
             MenuItem menuItem = new()
             {
                 Header = action.ButtonText,
                 IsCheckable = true,
                 Tag = action,
-                IsChecked = PostGrabActionManager.GetCheckState(action),
+                IsChecked = isChecked,
                 StaysOpenOnClick = stayOpen,
                 InputGestureText = $"Ctrl+{index}"
             };
@@ -301,10 +307,10 @@ private void LoadDynamicPostGrabActions()
 
         contextMenu.Items.Add(new Separator());
 
-        // Add "Edit this list..." menu item
+        // Add "Customize Actions & Templates..." menu item
         MenuItem editPostGrabMenuItem = new()
         {
-            Header = "Edit this list...",
+            Header = "✨ Customize Actions \u0026 Templates...",
             Tag = EditPostGrabActionsTag
         };
         editPostGrabMenuItem.Click += EditPostGrabActions_Click;
@@ -321,6 +327,46 @@ private void LoadDynamicPostGrabActions()
 
         // Update the dropdown button appearance
         CheckIfAnyPostActionsSelected();
+
+        // If a template was preselected (e.g. from Quick Simple Lookup), auto-check it
+        if (!string.IsNullOrEmpty(PreselectedTemplateId))
+        {
+            bool found = false;
+            foreach (object item in contextMenu.Items)
+            {
+                if (item is MenuItem mi
+                    && mi.Tag is ButtonInfo bi
+                    && bi.TemplateId == PreselectedTemplateId)
+                {
+                    mi.IsChecked = true;
+                    found = true;
+                    break;
+                }
+            }
+
+            // Template not in the enabled list — add it dynamically
+            if (!found)
+            {
+                GrabTemplate? template = GrabTemplateManager.GetTemplateById(PreselectedTemplateId);
+                if (template is not null)
+                {
+                    ButtonInfo templateAction = GrabTemplateManager.CreateButtonInfoForTemplate(template);
+                    MenuItem templateMenuItem = new()
+                    {
+                        Header = templateAction.ButtonText,
+                        IsCheckable = true,
+                        Tag = templateAction,
+                        IsChecked = true,
+                        StaysOpenOnClick = DefaultSettings.PostGrabStayOpen,
+                    };
+                    templateMenuItem.Click += PostActionMenuItem_Click;
+                    contextMenu.Items.Insert(contextMenu.Items.Count > 0 ? contextMenu.Items.Count - 2 : 0, new Separator());
+                    contextMenu.Items.Insert(contextMenu.Items.Count > 0 ? contextMenu.Items.Count - 2 : 0, templateMenuItem);
+                }
+            }
+
+            CheckIfAnyPostActionsSelected();
+        }
     }
 
     private void CancelMenuItem_Click(object sender, RoutedEventArgs e)
diff --git a/Text-Grab/Views/GrabFrame.xaml b/Text-Grab/Views/GrabFrame.xaml
index a61972c6..3acf7ae8 100644
--- a/Text-Grab/Views/GrabFrame.xaml
+++ b/Text-Grab/Views/GrabFrame.xaml
@@ -231,6 +231,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"
diff --git a/Text-Grab/Views/GrabFrame.xaml.cs b/Text-Grab/Views/GrabFrame.xaml.cs
index e2e031b9..9616786c 100644
--- a/Text-Grab/Views/GrabFrame.xaml.cs
+++ b/Text-Grab/Views/GrabFrame.xaml.cs
@@ -2480,6 +2480,12 @@ 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;
diff --git a/Text-Grab/Views/QuickSimpleLookup.xaml.cs b/Text-Grab/Views/QuickSimpleLookup.xaml.cs
index 8152f8d0..1fb78a04 100644
--- a/Text-Grab/Views/QuickSimpleLookup.xaml.cs
+++ b/Text-Grab/Views/QuickSimpleLookup.xaml.cs
@@ -14,6 +14,7 @@
 using System.Windows.Controls.Primitives;
 using System.Windows.Input;
 using System.Windows.Media;
+using Text_Grab.Controls;
 using Text_Grab.Models;
 using Text_Grab.Properties;
 using Text_Grab.Services;
@@ -468,6 +469,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 +522,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:
@@ -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))

From e411b46d434dbea569c72ec728b2c46f31a93361 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Tue, 3 Mar 2026 22:07:21 -0600
Subject: [PATCH 19/35] Fix ListView scrollbar, improve Post-Grab Actions UI

- Add ListViewScrollFix.xaml to correct scrollbar thumb sizing by properly binding ViewportSize in GridViewScrollViewerTemplate.
- Refactor PostGrabActionEditor layout for better scrolling and alignment using Grids and max heights.
- Replace "Open Grab Frame" with "New Template from Image" workflow; update button logic and help text accordingly.
- Change word region highlighting: referenced regions are now highlighted orange instead of dimming unused ones.
- Remove unused/hidden template edit button and clean up related code.
---
 Text-Grab/App.xaml                            |   1 +
 Text-Grab/Controls/PostGrabActionEditor.xaml  | 171 +++++++++---------
 .../Controls/PostGrabActionEditor.xaml.cs     |  23 ++-
 Text-Grab/Controls/WordBorder.xaml.cs         |  21 ++-
 Text-Grab/Styles/ListViewScrollFix.xaml       |  85 +++++++++
 Text-Grab/Views/GrabFrame.xaml.cs             |   6 +-
 6 files changed, 208 insertions(+), 99 deletions(-)
 create mode 100644 Text-Grab/Styles/ListViewScrollFix.xaml

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/PostGrabActionEditor.xaml b/Text-Grab/Controls/PostGrabActionEditor.xaml
index f061a50b..b2c9b960 100644
--- a/Text-Grab/Controls/PostGrabActionEditor.xaml
+++ b/Text-Grab/Controls/PostGrabActionEditor.xaml
@@ -29,7 +29,7 @@
         <Grid.RowDefinitions>
             <RowDefinition Height="Auto" />
             <RowDefinition Height="*" />
-            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto" MaxHeight="400" />
             <RowDefinition Height="Auto" />
         </Grid.RowDefinitions>
 
@@ -42,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"
@@ -65,7 +73,6 @@
                 <Grid>
                     <ui:ListView
                         x:Name="AvailableActionsListBox"
-                        MinHeight="240"
                         d:ItemsSource="{d:SampleData ItemCount=5}"
                         ScrollViewer.HorizontalScrollBarVisibility="Hidden"
                         ScrollViewer.VerticalScrollBarVisibility="Visible">
@@ -98,7 +105,7 @@
                         Visibility="Collapsed" />
                 </Grid>
             </Border>
-        </StackPanel>
+        </Grid>
 
         <!--  Move Buttons (Center)  -->
         <StackPanel
@@ -157,69 +164,77 @@
         </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="240"
-                    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
@@ -253,7 +268,7 @@
                         <TextBlock
                             FontSize="11"
                             Opacity="0.7"
-                            Text="Templates extract structured data from fixed-layout documents. Open a Grab Frame, use Ctrl+drag to draw regions, then click the Save as Template button. Add a template to the Enabled Actions list to use it during a Fullscreen Grab."
+                            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>
 
@@ -262,13 +277,13 @@
                         VerticalAlignment="Center"
                         Orientation="Horizontal">
                         <ui:Button
-                            x:Name="OpenGrabFrameButton"
+                            x:Name="NewTemplateFromImageButton"
                             Margin="0,0,6,0"
-                            Click="OpenGrabFrameButton_Click"
-                            ToolTip="Open a blank Grab Frame to draw regions and save as a new template">
+                            Click="NewTemplateFromImageButton_Click"
+                            ToolTip="Pick an image to use as reference for a new grab template">
                             <StackPanel Orientation="Horizontal">
-                                <ui:SymbolIcon FontSize="14" Symbol="Window24" />
-                                <TextBlock Margin="4,0,0,0" Text="Open Grab Frame" />
+                                <ui:SymbolIcon FontSize="14" Symbol="ImageAdd24" />
+                                <TextBlock Margin="4,0,0,0" Text="New Template from Image" />
                             </StackPanel>
                         </ui:Button>
                         <ui:Button
@@ -281,17 +296,6 @@
                                 <TextBlock Margin="4,0,0,0" Text="Edit Grab Template" />
                             </StackPanel>
                         </ui:Button>
-                        <ui:Button
-                            x:Name="EditTemplateButton"
-                            Margin="0,0,6,0"
-                            Click="EditTemplateButton_Click"
-                            ToolTip="Edit the selected template's name and output template"
-                            Visibility="Collapsed">
-                            <StackPanel Orientation="Horizontal">
-                                <ui:SymbolIcon FontSize="14" Symbol="Edit24" />
-                                <TextBlock Margin="4,0,0,0" Text="Edit" />
-                            </StackPanel>
-                        </ui:Button>
                         <ui:Button
                             x:Name="DeleteTemplateButton"
                             Click="DeleteTemplateButton_Click"
@@ -308,7 +312,6 @@
                 <Grid Grid.Row="1">
                     <ui:ListView
                         x:Name="TemplatesListBox"
-                        MaxHeight="140"
                         ScrollViewer.HorizontalScrollBarVisibility="Disabled"
                         ScrollViewer.VerticalScrollBarVisibility="Auto"
                         SelectionChanged="TemplatesListBox_SelectionChanged">
diff --git a/Text-Grab/Controls/PostGrabActionEditor.xaml.cs b/Text-Grab/Controls/PostGrabActionEditor.xaml.cs
index e7d0ebe2..6f037f7b 100644
--- a/Text-Grab/Controls/PostGrabActionEditor.xaml.cs
+++ b/Text-Grab/Controls/PostGrabActionEditor.xaml.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
+using System.IO;
 using System.Linq;
 using System.Windows;
 using System.Windows.Data;
@@ -218,9 +219,27 @@ private void UpdateTemplateEmptyState(int count)
         NoTemplatesText.Visibility = hasTemplates ? Visibility.Collapsed : Visibility.Visible;
     }
 
-    private void OpenGrabFrameButton_Click(object sender, RoutedEventArgs e)
+    private void NewTemplateFromImageButton_Click(object sender, RoutedEventArgs e)
     {
-        GrabFrame grabFrame = new();
+        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();
diff --git a/Text-Grab/Controls/WordBorder.xaml.cs b/Text-Grab/Controls/WordBorder.xaml.cs
index ec86d291..41f94eb6 100644
--- a/Text-Grab/Controls/WordBorder.xaml.cs
+++ b/Text-Grab/Controls/WordBorder.xaml.cs
@@ -174,26 +174,27 @@ public string Word
     public void Deselect()
     {
         IsSelected = false;
-        ApplyTemplateDimBorderBrush();
+        ApplyTemplateStateBorderBrush();
     }
 
-    private bool _isDimmedForTemplate = false;
+    private bool _isInOutputPattern = false;
 
     /// <summary>
-    /// Dims the border brush to indicate this region is not referenced in the output template.
-    /// Call with false to restore the normal border color.
+    /// 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 SetDimmedForTemplate(bool isDimmed)
+    public void SetHighlightedForOutput(bool isHighlighted)
     {
-        _isDimmedForTemplate = isDimmed;
+        _isInOutputPattern = isHighlighted;
         if (!IsSelected)
-            ApplyTemplateDimBorderBrush();
+            ApplyTemplateStateBorderBrush();
     }
 
-    private void ApplyTemplateDimBorderBrush()
+    private void ApplyTemplateStateBorderBrush()
     {
-        byte alpha = _isDimmedForTemplate ? (byte)80 : (byte)255;
-        SolidColorBrush brush = new(Color.FromArgb(alpha, 48, 142, 152));
+        SolidColorBrush brush = _isInOutputPattern
+            ? new SolidColorBrush(Colors.Orange)
+            : new SolidColorBrush(Color.FromRgb(48, 142, 152));
         WordBorderBorder.BorderBrush = brush;
         MoveResizeBorder.BorderBrush = brush;
     }
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/Views/GrabFrame.xaml.cs b/Text-Grab/Views/GrabFrame.xaml.cs
index 9616786c..bc42e3fe 100644
--- a/Text-Grab/Views/GrabFrame.xaml.cs
+++ b/Text-Grab/Views/GrabFrame.xaml.cs
@@ -2589,7 +2589,7 @@ private void UpdateTemplateBadges()
             {
                 wb.TemplateIndex = 0;
                 wb.Opacity = 1.0;
-                wb.SetDimmedForTemplate(false);
+                wb.SetHighlightedForOutput(false);
             }
             return;
         }
@@ -2615,8 +2615,8 @@ private void UpdateTemplateRegionOpacities()
         foreach (WordBorder wb in wordBorders)
         {
             bool isReferenced = referenced.Count == 0 || referenced.Contains(wb.TemplateIndex);
-            wb.Opacity = isReferenced ? 1.0 : 0.5;
-            wb.SetDimmedForTemplate(!isReferenced);
+            wb.Opacity = 1.0;
+            wb.SetHighlightedForOutput(isReferenced);
         }
     }
 

From aacf37ebcdc20707ee9441eb04738ac64cc2ba63 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Tue, 3 Mar 2026 22:33:00 -0600
Subject: [PATCH 20/35] Add regex pattern matching support to Grab Templates

Extend Grab Templates to support regex pattern placeholders alongside
existing region placeholders. Users can reference saved StoredRegex
patterns from the Regex Manager using {p:PatternName:mode} syntax.

New placeholder syntax:
- {p:Name:first} - first regex match
- {p:Name:last} - last regex match
- {p:Name:all:separator} - all matches joined by separator
- {p:Name:N} - Nth match (1-based)
- {p:Name:1,3} - specific matches joined by separator

Key changes:
- New TemplatePatternMatch model for pattern references
- GrabTemplate now supports pattern-only and hybrid templates
- GrabTemplateExecutor processes pattern placeholders via full-area OCR
- InlinePickerRichTextBox shows grouped popup (Regions/Patterns sections)
- PatternMatchModeDialog for configuring match mode after selection
- GrabFrame integrates pattern items in template editor
- 15 new tests covering all match modes and edge cases

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 Tests/GrabTemplateExecutorTests.cs            | 329 ++++++++++++++++++
 Text-Grab/Controls/InlinePickerItem.cs        |   9 +-
 Text-Grab/Controls/InlinePickerRichTextBox.cs | 189 +++++++++-
 .../Controls/PatternMatchModeDialog.xaml      |  87 +++++
 .../Controls/PatternMatchModeDialog.xaml.cs   | 119 +++++++
 Text-Grab/Models/GrabTemplate.cs              |  42 ++-
 Text-Grab/Models/TemplatePatternMatch.cs      |  53 +++
 Text-Grab/Utilities/GrabTemplateExecutor.cs   | 243 ++++++++++++-
 Text-Grab/Views/GrabFrame.xaml.cs             | 164 ++++++++-
 9 files changed, 1196 insertions(+), 39 deletions(-)
 create mode 100644 Text-Grab/Controls/PatternMatchModeDialog.xaml
 create mode 100644 Text-Grab/Controls/PatternMatchModeDialog.xaml.cs
 create mode 100644 Text-Grab/Models/TemplatePatternMatch.cs

diff --git a/Tests/GrabTemplateExecutorTests.cs b/Tests/GrabTemplateExecutorTests.cs
index 94f00754..18f17917 100644
--- a/Tests/GrabTemplateExecutorTests.cs
+++ b/Tests/GrabTemplateExecutorTests.cs
@@ -1,3 +1,4 @@
+using Text_Grab.Models;
 using Text_Grab.Utilities;
 
 namespace Tests;
@@ -143,4 +144,332 @@ public void ValidateOutputTemplate_NoRegionsReferenced_ReturnsIssue()
         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/Text-Grab/Controls/InlinePickerItem.cs b/Text-Grab/Controls/InlinePickerItem.cs
index fc3f82d2..da922a71 100644
--- a/Text-Grab/Controls/InlinePickerItem.cs
+++ b/Text-Grab/Controls/InlinePickerItem.cs
@@ -5,12 +5,19 @@ 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)
+    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
index c07a3208..d53b7dba 100644
--- a/Text-Grab/Controls/InlinePickerRichTextBox.cs
+++ b/Text-Grab/Controls/InlinePickerRichTextBox.cs
@@ -9,12 +9,14 @@
 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
 {
@@ -70,6 +72,13 @@ public string SerializedText
 
     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(
@@ -121,8 +130,8 @@ private ListBox BuildPopupListBox()
     {
         ListBox lb = new()
         {
-            MinWidth = 120,
-            MaxHeight = 150,
+            MinWidth = 140,
+            MaxHeight = 200,
             FontSize = 11,
             BorderThickness = new Thickness(0),
             Background = Brushes.Transparent,
@@ -131,7 +140,18 @@ private ListBox BuildPopupListBox()
         };
         lb.SetResourceReference(ForegroundProperty, "TextFillColorPrimaryBrush");
 
-        // Item template: DisplayName + muted Value label side-by-side
+        // 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);
@@ -153,11 +173,22 @@ private ListBox BuildPopupListBox()
         spFactory.AppendChild(nameFactory);
         spFactory.AppendChild(valueFactory);
         dt.VisualTree = spFactory;
-        lb.ItemTemplate = dt;
+        return dt;
+    }
 
-        lb.PreviewMouseDown += ListBox_PreviewMouseDown;
-        lb.ItemContainerStyle = BuildCompactItemStyle();
-        return lb;
+    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()
@@ -233,16 +264,12 @@ private void OnPreviewKeyDown(object sender, KeyEventArgs e)
         {
             case Key.Down:
                 e.Handled = true;
-                _listBox.SelectedIndex = (_listBox.SelectedIndex + 1) % Math.Max(1, _listBox.Items.Count);
-                _listBox.ScrollIntoView(_listBox.SelectedItem);
+                MoveSelection(1);
                 break;
 
             case Key.Up:
                 e.Handled = true;
-                _listBox.SelectedIndex = _listBox.SelectedIndex > 0
-                    ? _listBox.SelectedIndex - 1
-                    : _listBox.Items.Count - 1;
-                _listBox.ScrollIntoView(_listBox.SelectedItem);
+                MoveSelection(-1);
                 break;
 
             case Key.Enter:
@@ -271,6 +298,30 @@ private void OnPreviewKeyDown(object sender, KeyEventArgs e)
 
     #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)
@@ -317,8 +368,12 @@ private void RefreshPopup()
 
         _listBox.ItemsSource = filtered;
 
+        // Auto-select the first non-header item
         if (_listBox.SelectedIndex < 0 || _listBox.SelectedIndex >= filtered.Count)
-            _listBox.SelectedIndex = 0;
+        {
+            int firstSelectable = filtered.FindIndex(i => i.Group != HeaderGroupTag);
+            _listBox.SelectedIndex = firstSelectable >= 0 ? firstSelectable : 0;
+        }
 
         if (!_popup.IsOpen)
         {
@@ -341,13 +396,52 @@ private List<InlinePickerItem> GetFilteredItems()
 
         IEnumerable<InlinePickerItem> source = ItemsSource ?? [];
 
-        return filterText.Length == 0
+        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
@@ -372,6 +466,26 @@ private void CommitSelection()
         if (_listBox.SelectedItem is not InlinePickerItem selectedItem || _triggerStart == null)
             return;
 
+        // Skip non-selectable header items
+        if (selectedItem.Group == HeaderGroupTag)
+            return;
+
+        // 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)
+        {
+            TemplatePatternMatch? patternConfig = PatternItemSelected(selectedItem);
+            if (patternConfig == 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
         {
@@ -381,8 +495,8 @@ private void CommitSelection()
             // CaretPosition is now at the insertion point (where trigger was)
             InlineChipElement chip = new()
             {
-                DisplayName = selectedItem.DisplayName,
-                Value = selectedItem.Value,
+                DisplayName = itemToInsert.DisplayName,
+                Value = itemToInsert.Value,
             };
             chip.RemoveRequested += Chip_RemoveRequested;
 
@@ -397,7 +511,7 @@ private void CommitSelection()
 
             HidePopup();
             _triggerStart = null;
-            ItemInserted?.Invoke(this, selectedItem);
+            ItemInserted?.Invoke(this, itemToInsert);
         }
         finally
         {
@@ -408,6 +522,20 @@ private void CommitSelection()
         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)
@@ -566,3 +694,28 @@ private static bool IsVisualDescendant(DependencyObject? root, DependencyObject
         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/PatternMatchModeDialog.xaml b/Text-Grab/Controls/PatternMatchModeDialog.xaml
new file mode 100644
index 00000000..442428bc
--- /dev/null
+++ b/Text-Grab/Controls/PatternMatchModeDialog.xaml
@@ -0,0 +1,87 @@
+<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="320"
+    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
+                Margin="0,0,0,8"
+                FontWeight="SemiBold"
+                x:Name="PatternNameLabel"
+                Text="Pattern:" />
+
+            <TextBlock Margin="0,0,0,4" Text="Match Mode:" />
+            <ComboBox
+                x:Name="MatchModeComboBox"
+                Margin="0,0,0,12"
+                SelectedIndex="0"
+                SelectionChanged="MatchModeComboBox_SelectionChanged">
+                <ComboBoxItem Content="First Match" Tag="first" />
+                <ComboBoxItem Content="Last Match" Tag="last" />
+                <ComboBoxItem Content="All Matches" Tag="all" />
+                <ComboBoxItem Content="Specific Match(es)" Tag="nth" />
+            </ComboBox>
+
+            <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..2c6b2c8a
--- /dev/null
+++ b/Text-Grab/Controls/PatternMatchModeDialog.xaml.cs
@@ -0,0 +1,119 @@
+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 MatchModeComboBox_SelectionChanged(object sender, SelectionChangedEventArgs 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()
+    {
+        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)
+    {
+        IndicesErrorText.Text = message;
+        IndicesErrorText.Visibility = Visibility.Visible;
+        OkButton.IsEnabled = false;
+    }
+
+    private void HideIndicesError()
+    {
+        IndicesErrorText.Visibility = Visibility.Collapsed;
+        OkButton.IsEnabled = true;
+    }
+
+    private string GetSelectedMode()
+    {
+        if (MatchModeComboBox.SelectedItem is ComboBoxItem item)
+            return item.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/Models/GrabTemplate.cs b/Text-Grab/Models/GrabTemplate.cs
index e21ed33a..24a32960 100644
--- a/Text-Grab/Models/GrabTemplate.cs
+++ b/Text-Grab/Models/GrabTemplate.cs
@@ -8,11 +8,20 @@ namespace Text_Grab.Models;
 /// 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:
+/// 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
@@ -57,11 +66,18 @@ public class GrabTemplate
     public List<TemplateRegion> Regions { get; set; } = [];
 
     /// <summary>
-    /// Output format string. Use {N}, {N:trim}, {N:upper}, {N:lower}, \n, \t.
-    /// Example: "Name: {1}\nEmail: {2}\nPhone: {3}"
+    /// 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)
@@ -71,10 +87,12 @@ public GrabTemplate(string 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
+        && (Regions.Count > 0 || PatternMatches.Count > 0)
         && !string.IsNullOrWhiteSpace(OutputTemplate);
 
     /// <summary>
@@ -93,4 +111,20 @@ public IEnumerable<int> GetReferencedRegionNumbers()
                 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 =
+            System.Text.RegularExpressions.Regex.Matches(
+                OutputTemplate,
+                @"\{p:([^:}]+):[^}]+\}");
+
+        foreach (System.Text.RegularExpressions.Match match in matches)
+        {
+            yield return match.Groups[1].Value;
+        }
+    }
 }
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/Utilities/GrabTemplateExecutor.cs b/Text-Grab/Utilities/GrabTemplateExecutor.cs
index e3d3add4..90b82141 100644
--- a/Text-Grab/Utilities/GrabTemplateExecutor.cs
+++ b/Text-Grab/Utilities/GrabTemplateExecutor.cs
@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using System.Windows;
@@ -13,11 +15,20 @@ namespace Text_Grab.Utilities;
 /// OCRs each sub-region, then formats the results using the template's
 /// <see cref="GrabTemplate.OutputTemplate"/> string.
 ///
-/// Output template syntax:
+/// 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
@@ -29,6 +40,13 @@ public static class GrabTemplateExecutor
     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>
@@ -51,13 +69,39 @@ public static async Task<string> ExecuteTemplateAsync(
         if (!template.IsValid)
             return string.Empty;
 
-        // 1. OCR each region
         ILanguage resolvedLanguage = language ?? LanguageUtilities.GetOCRLanguage();
-        Dictionary<int, string> regionResults = await OcrAllRegionsAsync(
-            template, captureRegion, resolvedLanguage);
 
-        // 2. Apply output template
-        return ApplyOutputTemplate(template.OutputTemplate, regionResults);
+        // 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>
@@ -107,6 +151,151 @@ public static string ApplyOutputTemplate(
         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(
@@ -153,15 +342,19 @@ private static async Task<Dictionary<int, string>> OcrAllRegionsAsync(
     /// 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)
+    public static List<string> ValidateOutputTemplate(
+        string outputTemplate,
+        IEnumerable<int> availableRegionNumbers,
+        IEnumerable<string>? availablePatternNames = null)
     {
         List<string> issues = [];
         HashSet<int> available = [.. availableRegionNumbers];
 
-        MatchCollection matches = PlaceholderRegex.Matches(outputTemplate);
+        // Validate region placeholders
+        MatchCollection regionMatches = PlaceholderRegex.Matches(outputTemplate);
         HashSet<int> referenced = [];
 
-        foreach (Match match in matches)
+        foreach (Match match in regionMatches)
         {
             if (!int.TryParse(match.Groups[1].Value, out int num))
             {
@@ -181,6 +374,38 @@ public static List<string> ValidateOutputTemplate(string outputTemplate, IEnumer
                 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/Views/GrabFrame.xaml.cs b/Text-Grab/Views/GrabFrame.xaml.cs
index bc42e3fe..ab8c9d62 100644
--- a/Text-Grab/Views/GrabFrame.xaml.cs
+++ b/Text-Grab/Views/GrabFrame.xaml.cs
@@ -229,11 +229,39 @@ private async Task LoadTemplateForEditing(GrabTemplate template)
         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;
@@ -2512,11 +2540,16 @@ private void SaveTemplateSave_Click(object sender, RoutedEventArgs e)
             return;
         }
 
-        if (wordBorders.Count == 0)
+        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 before saving.",
-                "No Regions",
+                "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;
@@ -2540,10 +2573,11 @@ private void SaveTemplateSave_Click(object sender, RoutedEventArgs e)
 
         GrabTemplate template = new(name)
         {
-            OutputTemplate = TemplateOutputBox.GetSerializedText(),
+            OutputTemplate = outputTemplateText,
             ReferenceImageWidth = cw,
             ReferenceImageHeight = ch,
             Regions = regions,
+            PatternMatches = patternMatches,
         };
 
         if (_editingTemplate is not null)
@@ -2565,13 +2599,68 @@ private void SaveTemplateSave_Click(object sender, RoutedEventArgs e)
         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 {regions.Count} region(s).\n\nEnable it in Post-Grab Actions Settings to use it during a Fullscreen Grab.",
+            $"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 = Regex.Matches(outputTemplate, @"\{p:([^:}]+):([^:}]+)(?::([^}]*))?\}");
+        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;
@@ -2628,12 +2717,73 @@ private void TemplateOutputBox_TextChanged(object sender, TextChangedEventArgs e
     private void UpdateTemplatePickerItems()
     {
         List<WordBorder> sorted = [.. wordBorders.OrderBy(w => w.Top).ThenBy(w => w.Left)];
-        TemplateOutputBox.ItemsSource = [.. sorted
+
+        // 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}}}");
+                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)

From 20bc475567d08d391debc12f962563f11ad547f5 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Tue, 3 Mar 2026 22:38:01 -0600
Subject: [PATCH 21/35] Fix NullReferenceException in PatternMatchModeDialog

Add null guards for controls accessed during InitializeComponent before
XAML template is fully loaded (IndicesErrorText, OkButton, IndicesTextBox).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 Text-Grab/Controls/PatternMatchModeDialog.xaml.cs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Text-Grab/Controls/PatternMatchModeDialog.xaml.cs b/Text-Grab/Controls/PatternMatchModeDialog.xaml.cs
index 2c6b2c8a..47b80e7f 100644
--- a/Text-Grab/Controls/PatternMatchModeDialog.xaml.cs
+++ b/Text-Grab/Controls/PatternMatchModeDialog.xaml.cs
@@ -47,6 +47,9 @@ private void IndicesTextBox_TextChanged(object sender, TextChangedEventArgs e)
 
     private bool ValidateIndices()
     {
+        if (IndicesTextBox == null)
+            return true;
+
         string text = IndicesTextBox.Text.Trim();
         if (string.IsNullOrEmpty(text))
         {
@@ -76,6 +79,8 @@ private bool ValidateIndices()
 
     private void ShowIndicesError(string message)
     {
+        if (IndicesErrorText == null || OkButton == null)
+            return;
         IndicesErrorText.Text = message;
         IndicesErrorText.Visibility = Visibility.Visible;
         OkButton.IsEnabled = false;
@@ -83,6 +88,8 @@ private void ShowIndicesError(string message)
 
     private void HideIndicesError()
     {
+        if (IndicesErrorText == null || OkButton == null)
+            return;
         IndicesErrorText.Visibility = Visibility.Collapsed;
         OkButton.IsEnabled = true;
     }

From 6802c6ad4ee2067baf54af5bc24bff484baeafa3 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Tue, 3 Mar 2026 22:42:02 -0600
Subject: [PATCH 22/35] Fix ArgumentNullException in CommitSelection when
 dialog steals focus

Save _triggerStart before opening the PatternMatchModeDialog. The modal
dialog causes OnLostKeyboardFocus to fire, which nulls _triggerStart.
Using the saved pointer prevents the TextRange null argument crash.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 Text-Grab/Controls/InlinePickerRichTextBox.cs | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/Text-Grab/Controls/InlinePickerRichTextBox.cs b/Text-Grab/Controls/InlinePickerRichTextBox.cs
index d53b7dba..a3c34dbe 100644
--- a/Text-Grab/Controls/InlinePickerRichTextBox.cs
+++ b/Text-Grab/Controls/InlinePickerRichTextBox.cs
@@ -470,15 +470,24 @@ private void CommitSelection()
         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);
@@ -490,7 +499,7 @@ private void CommitSelection()
         try
         {
             // Delete from trigger position to current caret (removes "{" + typed filter text)
-            new TextRange(_triggerStart, CaretPosition).Text = string.Empty;
+            new TextRange(savedTriggerStart, CaretPosition).Text = string.Empty;
 
             // CaretPosition is now at the insertion point (where trigger was)
             InlineChipElement chip = new()

From 209ca5fc70611c4b00a7b75d8cd4770d6850f03f Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Tue, 3 Mar 2026 22:51:29 -0600
Subject: [PATCH 23/35] Skip region overlays in FSG for pattern-only templates

When a template's output references no regions (only pattern placeholders),
don't draw the region overlay rectangles during fullscreen grab selection.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 Text-Grab/Views/FullscreenGrab.xaml.cs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/Text-Grab/Views/FullscreenGrab.xaml.cs b/Text-Grab/Views/FullscreenGrab.xaml.cs
index 64630178..7500d5b1 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml.cs
+++ b/Text-Grab/Views/FullscreenGrab.xaml.cs
@@ -459,6 +459,11 @@ private void UpdateTemplateRegionOverlays(double selLeft, double selTop, double
         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;
 
@@ -474,8 +479,6 @@ private void UpdateTemplateRegionOverlays(double selLeft, double selTop, double
         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);
 
-        HashSet<int> referencedRegions = [.. template.GetReferencedRegionNumbers()];
-
         foreach (TemplateRegion region in template.Regions)
         {
             double regionLeft = region.RatioLeft * selWidth;

From 5205db27b99ba2f53f271f5072295c7e108e7b3d Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Wed, 4 Mar 2026 22:34:40 -0600
Subject: [PATCH 24/35] Refactor GrabTemplate, improve regex usage, cleanup
 code

Refactored GrabTemplate to a partial class and added a unique Id property. Replaced inline regex with [GeneratedRegex] partial methods for better performance. Simplified menu item check logic in FullscreenGrab. Removed an unused using directive from QuickSimpleLookup.
---
 Text-Grab/Models/GrabTemplate.cs          | 16 +++++++++-------
 Text-Grab/Views/FullscreenGrab.xaml.cs    |  4 +---
 Text-Grab/Views/QuickSimpleLookup.xaml.cs |  1 -
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/Text-Grab/Models/GrabTemplate.cs b/Text-Grab/Models/GrabTemplate.cs
index 24a32960..986de995 100644
--- a/Text-Grab/Models/GrabTemplate.cs
+++ b/Text-Grab/Models/GrabTemplate.cs
@@ -27,7 +27,7 @@ namespace Text_Grab.Models;
 ///   \\           — literal backslash
 ///   \{           — literal opening brace
 /// </summary>
-public class GrabTemplate
+public partial class GrabTemplate
 {
     /// <summary>Unique persistent identifier.</summary>
     public string Id { get; set; } = Guid.NewGuid().ToString();
@@ -101,9 +101,7 @@ public GrabTemplate(string name)
     public IEnumerable<int> GetReferencedRegionNumbers()
     {
         System.Text.RegularExpressions.MatchCollection matches =
-            System.Text.RegularExpressions.Regex.Matches(
-                OutputTemplate,
-                @"\{(\d+)(?::[a-z]+)?\}");
+            RefRegionNumbers().Matches(OutputTemplate);
 
         foreach (System.Text.RegularExpressions.Match match in matches)
         {
@@ -118,13 +116,17 @@ public IEnumerable<int> GetReferencedRegionNumbers()
     public IEnumerable<string> GetReferencedPatternNames()
     {
         System.Text.RegularExpressions.MatchCollection matches =
-            System.Text.RegularExpressions.Regex.Matches(
-                OutputTemplate,
-                @"\{p:([^:}]+):[^}]+\}");
+            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/Views/FullscreenGrab.xaml.cs b/Text-Grab/Views/FullscreenGrab.xaml.cs
index 7500d5b1..92d4b375 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml.cs
+++ b/Text-Grab/Views/FullscreenGrab.xaml.cs
@@ -284,9 +284,7 @@ private void LoadDynamicPostGrabActions()
         foreach (ButtonInfo action in enabledActions)
         {
             // When a template is preselected, don't restore saved check state for other templates
-            bool isChecked = !string.IsNullOrEmpty(PreselectedTemplateId) && !string.IsNullOrEmpty(action.TemplateId)
-                ? false
-                : PostGrabActionManager.GetCheckState(action);
+            bool isChecked = (string.IsNullOrEmpty(PreselectedTemplateId) || string.IsNullOrEmpty(action.TemplateId)) && PostGrabActionManager.GetCheckState(action);
 
             MenuItem menuItem = new()
             {
diff --git a/Text-Grab/Views/QuickSimpleLookup.xaml.cs b/Text-Grab/Views/QuickSimpleLookup.xaml.cs
index 1fb78a04..09a8ed18 100644
--- a/Text-Grab/Views/QuickSimpleLookup.xaml.cs
+++ b/Text-Grab/Views/QuickSimpleLookup.xaml.cs
@@ -14,7 +14,6 @@
 using System.Windows.Controls.Primitives;
 using System.Windows.Input;
 using System.Windows.Media;
-using Text_Grab.Controls;
 using Text_Grab.Models;
 using Text_Grab.Properties;
 using Text_Grab.Services;

From 78c3762480969e192da0105a5be812fdbeb51f24 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Wed, 4 Mar 2026 22:57:46 -0600
Subject: [PATCH 25/35] Sync overlay canvas to DIP; use [GeneratedRegex]
 patterns

Image/canvas sizing now uses device-independent pixels (DIPs)
to ensure overlays align correctly at all DPI scales. Replaces
inline regexes for template parsing with [GeneratedRegex] static
partial methods for improved performance and maintainability.
---
 Text-Grab/Views/GrabFrame.xaml.cs | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/Text-Grab/Views/GrabFrame.xaml.cs b/Text-Grab/Views/GrabFrame.xaml.cs
index ab8c9d62..9bb01ab4 100644
--- a/Text-Grab/Views/GrabFrame.xaml.cs
+++ b/Text-Grab/Views/GrabFrame.xaml.cs
@@ -1483,9 +1483,14 @@ private void SyncRectanglesCanvasSizeToImage()
         if (GrabFrameImage.Source is not BitmapSource source)
             return;
 
-        // Keep image and overlay in the same coordinate space (raw image pixels).
-        double sourceWidth = source.PixelWidth > 0 ? source.PixelWidth : source.Width;
-        double sourceHeight = source.PixelHeight > 0 ? source.PixelHeight : source.Height;
+        // 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)
         {
@@ -2622,7 +2627,7 @@ private static List<TemplatePatternMatch> ParsePatternMatchesFromTemplate(string
         if (string.IsNullOrEmpty(outputTemplate))
             return [];
 
-        MatchCollection matches = Regex.Matches(outputTemplate, @"\{p:([^:}]+):([^:}]+)(?::([^}]*))?\}");
+        MatchCollection matches = TemplatePattern().Matches(outputTemplate);
         Dictionary<string, TemplatePatternMatch> uniquePatterns = new(StringComparer.OrdinalIgnoreCase);
 
         // Load saved patterns for ID resolution
@@ -2697,7 +2702,7 @@ private void UpdateTemplateRegionOpacities()
             return;
 
         string outputTemplate = TemplateOutputBox.GetSerializedText();
-        HashSet<int> referenced = [.. Regex.Matches(outputTemplate, @"\{(\d+)(?::[a-z]+)?\}")
+        HashSet<int> referenced = [.. OutputTemplateReferenced().Matches(outputTemplate)
             .Select(m => int.TryParse(m.Groups[1].Value, out int n) ? n : 0)
             .Where(n => n > 0)];
 
@@ -3722,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
 }

From 87e0c38a3c338d1e94c10fbb5704d32d771e9c87 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 05:17:42 +0000
Subject: [PATCH 26/35] Initial plan


From 90a8704d368b7121c6df0c5edc5fe315ca6fc05b Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Mar 2026 05:21:54 +0000
Subject: [PATCH 27/35] fix: address review feedback on docs, error messages,
 and unused variables

Co-authored-by: TheJoeFin <7809853+TheJoeFin@users.noreply.github.com>
---
 Text-Grab/Utilities/GrabTemplateExecutor.cs | 8 ++++----
 Text-Grab/Views/FullscreenGrab.xaml.cs      | 8 ++------
 2 files changed, 6 insertions(+), 10 deletions(-)

diff --git a/Text-Grab/Utilities/GrabTemplateExecutor.cs b/Text-Grab/Utilities/GrabTemplateExecutor.cs
index 90b82141..52ead768 100644
--- a/Text-Grab/Utilities/GrabTemplateExecutor.cs
+++ b/Text-Grab/Utilities/GrabTemplateExecutor.cs
@@ -56,9 +56,9 @@ public static class GrabTemplateExecutor
     /// </summary>
     /// <param name="template">The template to execute.</param>
     /// <param name="captureRegion">
-    ///     The screen rectangle (in WPF units, pre-DPI-scaling applied by caller)
-    ///     that bounds the user's selection. Template region ratios are applied to
-    ///     this rectangle's width/height.
+    ///     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(
@@ -363,7 +363,7 @@ public static List<string> ValidateOutputTemplate(
             }
 
             if (!available.Contains(num))
-                issues.Add($"Placeholder {{{{num}}}} references region {num} which does not exist.");
+                issues.Add($"Placeholder {{{num}}} references region {num} which does not exist.");
 
             referenced.Add(num);
         }
diff --git a/Text-Grab/Views/FullscreenGrab.xaml.cs b/Text-Grab/Views/FullscreenGrab.xaml.cs
index 92d4b375..787afee2 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml.cs
+++ b/Text-Grab/Views/FullscreenGrab.xaml.cs
@@ -445,8 +445,8 @@ private void FullscreenGrab_KeyUp(object sender, KeyEventArgs e)
 
     /// <summary>
     /// Draws scaled template region overlays inside the current selection border.
-    /// Regions are scaled using UniformToFill semantics relative to the template's
-    /// reference image dimensions so they fill the selected area proportionally.
+    /// 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)
     {
@@ -465,10 +465,6 @@ private void UpdateTemplateRegionOverlays(double selLeft, double selTop, double
         if (selWidth < 4 || selHeight < 4)
             return;
 
-        // Stretch: scale each axis independently to fill the selection exactly
-        double scaleX = selWidth / template.ReferenceImageWidth;
-        double scaleY = selHeight / template.ReferenceImageHeight;
-
         templateOverlayCanvas.Width = selWidth;
         templateOverlayCanvas.Height = selHeight;
         Canvas.SetLeft(templateOverlayCanvas, selLeft);

From 8bf9482dad1b0d33ed280872f648faf5f02558c8 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Wed, 4 Mar 2026 23:46:52 -0600
Subject: [PATCH 28/35] Refactor context menu for post-grab actions and
 templates

Separate regular actions and templates in the context menu, add section separators, and improve handling of preselected templates. Enforce exclusive selection among template actions and ensure check states are managed correctly. Improves menu clarity, usability, and robustness.
---
 Text-Grab/Views/FullscreenGrab.xaml.cs | 69 ++++++++++++++++++++++----
 1 file changed, 59 insertions(+), 10 deletions(-)

diff --git a/Text-Grab/Views/FullscreenGrab.xaml.cs b/Text-Grab/Views/FullscreenGrab.xaml.cs
index 787afee2..b86117d9 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml.cs
+++ b/Text-Grab/Views/FullscreenGrab.xaml.cs
@@ -1,6 +1,7 @@
 using Dapplo.Windows.User32;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Drawing;
 using System.Threading.Tasks;
 using System.Windows;
@@ -280,11 +281,14 @@ private void LoadDynamicPostGrabActions()
         // Add keyboard handling once for the entire context menu
         contextMenu.PreviewKeyDown += FullscreenGrab_KeyDown;
 
+        List<ButtonInfo> regularActions = enabledActions.Where(a => string.IsNullOrEmpty(a.TemplateId)).ToList();
+        List<ButtonInfo> templateActions = enabledActions.Where(a => !string.IsNullOrEmpty(a.TemplateId)).ToList();
+        bool templatePreselected = !string.IsNullOrEmpty(PreselectedTemplateId);
+
         int index = 1;
-        foreach (ButtonInfo action in enabledActions)
+        foreach (ButtonInfo action in regularActions)
         {
-            // When a template is preselected, don't restore saved check state for other templates
-            bool isChecked = (string.IsNullOrEmpty(PreselectedTemplateId) || string.IsNullOrEmpty(action.TemplateId)) && PostGrabActionManager.GetCheckState(action);
+            bool isChecked = PostGrabActionManager.GetCheckState(action);
 
             MenuItem menuItem = new()
             {
@@ -296,9 +300,30 @@ private void LoadDynamicPostGrabActions()
                 InputGestureText = $"Ctrl+{index}"
             };
 
-            // Wire up click handler
             menuItem.Click += PostActionMenuItem_Click;
+            contextMenu.Items.Add(menuItem);
+            index++;
+        }
 
+        // Separator between regular actions and grab templates
+        if (regularActions.Count > 0 && templateActions.Count > 0)
+            contextMenu.Items.Add(new Separator());
+
+        foreach (ButtonInfo action in templateActions)
+        {
+            bool isChecked = !templatePreselected && PostGrabActionManager.GetCheckState(action);
+
+            MenuItem menuItem = new()
+            {
+                Header = action.ButtonText,
+                IsCheckable = true,
+                Tag = action,
+                IsChecked = isChecked,
+                StaysOpenOnClick = stayOpen,
+                InputGestureText = $"Ctrl+{index}"
+            };
+
+            menuItem.Click += PostActionMenuItem_Click;
             contextMenu.Items.Add(menuItem);
             index++;
         }
@@ -358,8 +383,10 @@ private void LoadDynamicPostGrabActions()
                         StaysOpenOnClick = DefaultSettings.PostGrabStayOpen,
                     };
                     templateMenuItem.Click += PostActionMenuItem_Click;
-                    contextMenu.Items.Insert(contextMenu.Items.Count > 0 ? contextMenu.Items.Count - 2 : 0, new Separator());
-                    contextMenu.Items.Insert(contextMenu.Items.Count > 0 ? contextMenu.Items.Count - 2 : 0, templateMenuItem);
+                    // Add section separator before templates if none exist yet (trailing: Separator, Customize, Close)
+                    if (!templateActions.Any())
+                        contextMenu.Items.Insert(contextMenu.Items.Count - 3, new Separator());
+                    contextMenu.Items.Insert(contextMenu.Items.Count - 3, templateMenuItem);
                 }
             }
 
@@ -1303,12 +1330,34 @@ 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 || menuItem.Tag is not ButtonInfo action)
         {
+            CheckIfAnyPostActionsSelected();
+            return;
+        }
+
+        // Save check state for LastUsed tracking
+        if (action.DefaultCheckState == DefaultCheckState.LastUsed)
             PostGrabActionManager.SaveCheckState(action, menuItem.IsChecked);
+
+        // Enforce exclusive template selection: when a template is checked, uncheck all others
+        if (!string.IsNullOrEmpty(action.TemplateId)
+            && menuItem.IsChecked
+            && menuItem.Parent is ContextMenu contextMenu)
+        {
+            foreach (object item in contextMenu.Items)
+            {
+                if (item is MenuItem otherItem
+                    && otherItem != menuItem
+                    && otherItem.Tag is ButtonInfo otherAction
+                    && !string.IsNullOrEmpty(otherAction.TemplateId)
+                    && otherItem.IsChecked)
+                {
+                    otherItem.IsChecked = false;
+                    if (otherAction.DefaultCheckState == DefaultCheckState.LastUsed)
+                        PostGrabActionManager.SaveCheckState(otherAction, false);
+                }
+            }
         }
 
         CheckIfAnyPostActionsSelected();

From d606fecef461e8516886df49824155e664d22a72 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Fri, 6 Mar 2026 10:56:32 -0600
Subject: [PATCH 29/35] Synchronize post-grab actions across FullscreenGrab
 windows
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Implement centralized state management and synchronization for post-grab actions (including templates and custom actions) across all open FullscreenGrab windows. Refactor menu item handling to use snapshot-based logic, ensuring exclusive template selection and consistent "LastUsed" persistence. Add keyboard shortcut support (Ctrl+1–9) for toggling actions and propagate changes to all windows. Update UI refresh logic and introduce comprehensive unit and WPF tests for the new synchronization features.
---
 Tests/FullscreenGrabPostGrabActionTests.cs | 127 +++++++
 Text-Grab/Utilities/WindowUtilities.cs     |  31 ++
 Text-Grab/Views/FullscreenGrab.xaml.cs     | 379 +++++++++++++--------
 3 files changed, 393 insertions(+), 144 deletions(-)
 create mode 100644 Tests/FullscreenGrabPostGrabActionTests.cs

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/Text-Grab/Utilities/WindowUtilities.cs b/Text-Grab/Utilities/WindowUtilities.cs
index b0a20563..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;
@@ -94,6 +96,9 @@ public static void LaunchFullScreenGrab(TextBox? destinationTextBox, string? pre
             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++)
@@ -157,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 = "";
@@ -203,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/FullscreenGrab.xaml.cs b/Text-Grab/Views/FullscreenGrab.xaml.cs
index b86117d9..0a70f868 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml.cs
+++ b/Text-Grab/Views/FullscreenGrab.xaml.cs
@@ -206,19 +206,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
@@ -232,14 +220,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;
@@ -261,6 +310,131 @@ private static bool CheckIfCheckingOrUnchecking(object? sender)
         return isActive;
     }
 
+    private void RefreshPostGrabActionVisuals()
+    {
+        CheckIfAnyPostActionsSelected();
+
+        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 = $"Ctrl+{shortcutIndex}"
+        };
+
+        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)
@@ -269,16 +443,11 @@ 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)).ToList();
@@ -288,49 +457,25 @@ private void LoadDynamicPostGrabActions()
         int index = 1;
         foreach (ButtonInfo action in regularActions)
         {
-            bool isChecked = PostGrabActionManager.GetCheckState(action);
-
-            MenuItem menuItem = new()
-            {
-                Header = action.ButtonText,
-                IsCheckable = true,
-                Tag = action,
-                IsChecked = isChecked,
-                StaysOpenOnClick = stayOpen,
-                InputGestureText = $"Ctrl+{index}"
-            };
-
-            menuItem.Click += PostActionMenuItem_Click;
-            contextMenu.Items.Add(menuItem);
+            AddPostGrabActionMenuItem(contextMenu, action, PostGrabActionManager.GetCheckState(action), stayOpen, index);
             index++;
         }
 
-        // Separator between regular actions and grab templates
         if (regularActions.Count > 0 && templateActions.Count > 0)
             contextMenu.Items.Add(new Separator());
 
         foreach (ButtonInfo action in templateActions)
         {
-            bool isChecked = !templatePreselected && PostGrabActionManager.GetCheckState(action);
-
-            MenuItem menuItem = new()
-            {
-                Header = action.ButtonText,
-                IsCheckable = true,
-                Tag = action,
-                IsChecked = isChecked,
-                StaysOpenOnClick = stayOpen,
-                InputGestureText = $"Ctrl+{index}"
-            };
+            bool isChecked = templatePreselected
+                ? action.TemplateId == PreselectedTemplateId
+                : PostGrabActionManager.GetCheckState(action);
 
-            menuItem.Click += PostActionMenuItem_Click;
-            contextMenu.Items.Add(menuItem);
+            AddPostGrabActionMenuItem(contextMenu, action, isChecked, stayOpen, index);
             index++;
         }
 
         contextMenu.Items.Add(new Separator());
 
-        // Add "Customize Actions & Templates..." menu item
         MenuItem editPostGrabMenuItem = new()
         {
             Header = "✨ Customize Actions \u0026 Templates...",
@@ -348,50 +493,14 @@ private void LoadDynamicPostGrabActions()
         hidePostGrabMenuItem.Click += HidePostGrabActions_Click;
         contextMenu.Items.Add(hidePostGrabMenuItem);
 
-        // Update the dropdown button appearance
-        CheckIfAnyPostActionsSelected();
-
-        // If a template was preselected (e.g. from Quick Simple Lookup), auto-check it
-        if (!string.IsNullOrEmpty(PreselectedTemplateId))
+        IReadOnlyDictionary<string, bool>? synchronizedActionStates = WindowUtilities.GetFullscreenPostGrabActionStates();
+        if (synchronizedActionStates is not null)
         {
-            bool found = false;
-            foreach (object item in contextMenu.Items)
-            {
-                if (item is MenuItem mi
-                    && mi.Tag is ButtonInfo bi
-                    && bi.TemplateId == PreselectedTemplateId)
-                {
-                    mi.IsChecked = true;
-                    found = true;
-                    break;
-                }
-            }
-
-            // Template not in the enabled list — add it dynamically
-            if (!found)
-            {
-                GrabTemplate? template = GrabTemplateManager.GetTemplateById(PreselectedTemplateId);
-                if (template is not null)
-                {
-                    ButtonInfo templateAction = GrabTemplateManager.CreateButtonInfoForTemplate(template);
-                    MenuItem templateMenuItem = new()
-                    {
-                        Header = templateAction.ButtonText,
-                        IsCheckable = true,
-                        Tag = templateAction,
-                        IsChecked = true,
-                        StaysOpenOnClick = DefaultSettings.PostGrabStayOpen,
-                    };
-                    templateMenuItem.Click += PostActionMenuItem_Click;
-                    // Add section separator before templates if none exist yet (trailing: Separator, Customize, Close)
-                    if (!templateActions.Any())
-                        contextMenu.Items.Insert(contextMenu.Items.Count - 3, new Separator());
-                    contextMenu.Items.Insert(contextMenu.Items.Count - 3, templateMenuItem);
-                }
-            }
-
-            CheckIfAnyPostActionsSelected();
+            ApplyPostGrabActionSnapshot(synchronizedActionStates);
+            return;
         }
+
+        RefreshPostGrabActionVisuals();
     }
 
     private void CancelMenuItem_Click(object sender, RoutedEventArgs e)
@@ -433,6 +542,16 @@ private async void FreezeUnfreeze(bool Activate)
 
     private void FullscreenGrab_KeyDown(object sender, KeyEventArgs e)
     {
+        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);
     }
 
@@ -455,10 +574,9 @@ private void FullscreenGrab_KeyUp(object sender, KeyEventArgs e)
         if (NextStepDropDownButton.Flyout is not ContextMenu contextMenu)
             return null;
 
-        foreach (object item in contextMenu.Items)
+        foreach (MenuItem menuItem in GetActionablePostGrabMenuItems(contextMenu))
         {
-            if (item is MenuItem menuItem
-                && menuItem.IsChecked
+            if (menuItem.IsChecked
                 && menuItem.Tag is ButtonInfo action
                 && action.ClickEvent == "ApplyTemplate_Click"
                 && !string.IsNullOrEmpty(action.TemplateId))
@@ -982,38 +1100,33 @@ private async void RegionClickCanvas_MouseUp(object sender, MouseButtonEventArgs
         {
             bool shouldInsert = false;
 
-            foreach (object item in contextMenu.Items)
+            foreach (MenuItem menuItem in GetActionablePostGrabMenuItems(contextMenu))
             {
-                if (item is MenuItem menuItem && menuItem.IsChecked && menuItem.Tag is ButtonInfo action)
+                if (!menuItem.IsChecked || menuItem.Tag is not ButtonInfo action)
+                    continue;
+
+                if (action.ClickEvent == "Insert_Click")
                 {
-                    // Special handling for Insert action - defer until after window closes
-                    if (action.ClickEvent == "Insert_Click")
-                    {
-                        shouldInsert = true;
-                        continue;
-                    }
+                    shouldInsert = true;
+                    continue;
+                }
 
-                    // Build context for this action (text may have changed from previous actions)
-                    PostGrabContext grabContext = new(
-                        Text: TextFromOCR ?? string.Empty,
-                        CaptureRegion: absoluteCaptureRect,
-                        DpiScale: m.M11,
-                        CapturedImage: null,
-                        Language: selectedOcrLang);
+                PostGrabContext grabContext = new(
+                    Text: TextFromOCR ?? string.Empty,
+                    CaptureRegion: absoluteCaptureRect,
+                    DpiScale: m.M11,
+                    CapturedImage: null,
+                    Language: selectedOcrLang);
 
-                    // Execute the action
-                    TextFromOCR = await PostGrabActionManager.ExecutePostGrabAction(action, grabContext);
-                }
+                TextFromOCR = await PostGrabActionManager.ExecutePostGrabAction(action, grabContext);
             }
 
-            // 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 Task.Delay(100);
                     await WindowUtilities.TryInsertString(textToInsert);
                 });
             }
@@ -1026,9 +1139,11 @@ private async void RegionClickCanvas_MouseUp(object sender, MouseButtonEventArgs
             bool isWebSearch = false;
             if (NextStepDropDownButton.Flyout is ContextMenu cm)
             {
-                foreach (object item in cm.Items)
+                foreach (MenuItem menuItem in GetActionablePostGrabMenuItems(cm))
                 {
-                    if (item is MenuItem mi && mi.IsChecked && mi.Tag is ButtonInfo act && act.ClickEvent == "WebSearch_Click")
+                    if (menuItem.IsChecked
+                        && menuItem.Tag is ButtonInfo action
+                        && action.ClickEvent == "WebSearch_Click")
                     {
                         isWebSearch = true;
                         break;
@@ -1330,37 +1445,13 @@ private void TableToggleButton_Click(object? sender = null, RoutedEventArgs? e =
 
     private void PostActionMenuItem_Click(object sender, RoutedEventArgs e)
     {
-        if (sender is not MenuItem menuItem || menuItem.Tag is not ButtonInfo action)
+        if (sender is not MenuItem menuItem)
         {
-            CheckIfAnyPostActionsSelected();
+            RefreshPostGrabActionVisuals();
             return;
         }
 
-        // Save check state for LastUsed tracking
-        if (action.DefaultCheckState == DefaultCheckState.LastUsed)
-            PostGrabActionManager.SaveCheckState(action, menuItem.IsChecked);
-
-        // Enforce exclusive template selection: when a template is checked, uncheck all others
-        if (!string.IsNullOrEmpty(action.TemplateId)
-            && menuItem.IsChecked
-            && menuItem.Parent is ContextMenu contextMenu)
-        {
-            foreach (object item in contextMenu.Items)
-            {
-                if (item is MenuItem otherItem
-                    && otherItem != menuItem
-                    && otherItem.Tag is ButtonInfo otherAction
-                    && !string.IsNullOrEmpty(otherAction.TemplateId)
-                    && otherItem.IsChecked)
-                {
-                    otherItem.IsChecked = false;
-                    if (otherAction.DefaultCheckState == DefaultCheckState.LastUsed)
-                        PostGrabActionManager.SaveCheckState(otherAction, false);
-                }
-            }
-        }
-
-        CheckIfAnyPostActionsSelected();
+        SynchronizePostGrabActionSelection(menuItem, menuItem.IsChecked);
     }
     #endregion Methods
 

From 2b7bfce4df16b611fc7fcacd360e1c27de404af8 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Fri, 6 Mar 2026 16:58:06 -0600
Subject: [PATCH 30/35] Add fullscreen grab selection styles

Introduce region, window, freeform, and adjust-after selection styles for Fullscreen Grab, wire the new UI and settings surfaces, and add focused tests for the supporting models and utilities.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 Tests/FreeformCaptureUtilitiesTests.cs        |   63 +
 Tests/FullscreenCaptureResultTests.cs         |   32 +
 Tests/FullscreenGrabSelectionStyleTests.cs    |   74 +
 Tests/WindowSelectionUtilitiesTests.cs        |   33 +
 Text-Grab/Enums.cs                            |    8 +
 Text-Grab/Models/FullscreenCaptureResult.cs   |   18 +
 Text-Grab/Models/HistoryInfo.cs               |    2 +
 Text-Grab/Models/PostGrabContext.cs           |    7 +-
 Text-Grab/Models/WindowSelectionCandidate.cs  |   13 +
 Text-Grab/OSInterop.cs                        |   41 +-
 Text-Grab/Pages/FullscreenGrabSettings.xaml   |   36 +
 .../Pages/FullscreenGrabSettings.xaml.cs      |   50 +
 Text-Grab/Properties/Settings.Designer.cs     |   12 +
 Text-Grab/Properties/Settings.settings        |    3 +
 .../SelectionStyleComboBoxItemStyle.xaml      |   52 +
 .../Styles/SelectionStyleComboBoxStyle.xaml   |  106 ++
 Text-Grab/Styles/TextStyles.xaml              |   12 +-
 .../Utilities/FreeformCaptureUtilities.cs     |   70 +
 Text-Grab/Utilities/OcrUtilities.cs           |   72 +-
 .../Utilities/WindowSelectionUtilities.cs     |  132 ++
 .../Views/FullscreenGrab.SelectionStyles.cs   | 1289 +++++++++++++++++
 Text-Grab/Views/FullscreenGrab.xaml           |   85 +-
 Text-Grab/Views/FullscreenGrab.xaml.cs        |  296 +---
 Text-Grab/Views/GrabFrame.xaml                |    8 -
 24 files changed, 2239 insertions(+), 275 deletions(-)
 create mode 100644 Tests/FreeformCaptureUtilitiesTests.cs
 create mode 100644 Tests/FullscreenCaptureResultTests.cs
 create mode 100644 Tests/FullscreenGrabSelectionStyleTests.cs
 create mode 100644 Tests/WindowSelectionUtilitiesTests.cs
 create mode 100644 Text-Grab/Models/FullscreenCaptureResult.cs
 create mode 100644 Text-Grab/Models/WindowSelectionCandidate.cs
 create mode 100644 Text-Grab/Styles/SelectionStyleComboBoxItemStyle.xaml
 create mode 100644 Text-Grab/Styles/SelectionStyleComboBoxStyle.xaml
 create mode 100644 Text-Grab/Utilities/FreeformCaptureUtilities.cs
 create mode 100644 Text-Grab/Utilities/WindowSelectionUtilities.cs
 create mode 100644 Text-Grab/Views/FullscreenGrab.SelectionStyles.cs

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/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/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/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/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/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/PostGrabContext.cs b/Text-Grab/Models/PostGrabContext.cs
index 63707a09..0644634c 100644
--- a/Text-Grab/Models/PostGrabContext.cs
+++ b/Text-Grab/Models/PostGrabContext.cs
@@ -27,10 +27,13 @@ public record PostGrabContext(
     BitmapSource? CapturedImage,
 
     /// <summary>The OCR language used for the capture. Null means use the app default.</summary>
-    ILanguage? Language = null
+    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);
+        new(text, Rect.Empty, 1.0, null, null, FsgSelectionStyle.Region);
 }
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 57d04d05..19cbf5f1 100644
--- a/Text-Grab/Pages/FullscreenGrabSettings.xaml
+++ b/Text-Grab/Pages/FullscreenGrabSettings.xaml
@@ -52,6 +52,42 @@
                 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"
diff --git a/Text-Grab/Pages/FullscreenGrabSettings.xaml.cs b/Text-Grab/Pages/FullscreenGrabSettings.xaml.cs
index 4d63762c..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;
@@ -168,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 6c4d60c4..05bf5d8e 100644
--- a/Text-Grab/Properties/Settings.Designer.cs
+++ b/Text-Grab/Properties/Settings.Designer.cs
@@ -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")]
diff --git a/Text-Grab/Properties/Settings.settings b/Text-Grab/Properties/Settings.settings
index ac20c5b4..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>
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/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/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/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/Views/FullscreenGrab.SelectionStyles.cs b/Text-Grab/Views/FullscreenGrab.SelectionStyles.cs
new file mode 100644
index 00000000..665d8d75
--- /dev/null
+++ b/Text-Grab/Views/FullscreenGrab.SelectionStyles.cs
@@ -0,0 +1,1289 @@
+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 = 10.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();
+
+            int cropX = Math.Max(0, (int)Math.Round(selectionRect.Left * transformToDevice.M11));
+            int cropY = Math.Max(0, (int)Math.Round(selectionRect.Top * transformToDevice.M22));
+            int cropW = Math.Min((int)Math.Round(selectionRect.Width * transformToDevice.M11), backgroundBitmap.PixelWidth - cropX);
+            int cropH = Math.Min((int)Math.Round(selectionRect.Height * transformToDevice.M22), backgroundBitmap.PixelHeight - cropY);
+
+            if (cropW > 0 && cropH > 0)
+            {
+                CroppedBitmap croppedBitmap = new(backgroundBitmap, new Int32Rect(cropX, cropY, cropW, cropH));
+                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 231ddc76..90717c49 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="P"
+                            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,7 @@
                 </ContextMenu>
             </Canvas.ContextMenu>
         </Canvas>
+        <Canvas x:Name="SelectionOutlineHost" IsHitTestVisible="False" />
         <Canvas x:Name="TemplateOverlayHost" IsHitTestVisible="False" />
         <Border
             x:Name="TopButtonsStackPanel"
@@ -138,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"
@@ -290,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 0a70f868..d8cf5f2e 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml.cs
+++ b/Text-Grab/Views/FullscreenGrab.xaml.cs
@@ -2,7 +2,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Drawing;
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
@@ -12,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;
@@ -63,6 +61,7 @@ public FullscreenGrab()
         InitializeComponent();
         App.SetTheme();
         usingTesseract = DefaultSettings.UseTesseract && TesseractHelper.CanLocateTesseractExe();
+        InitializeSelectionStyles();
 
         edgePanTimer = new DispatcherTimer
         {
@@ -194,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:
@@ -314,6 +325,13 @@ 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)
@@ -450,8 +468,8 @@ private void LoadDynamicPostGrabActions()
         contextMenu.PreviewKeyDown -= FullscreenGrab_KeyDown;
         contextMenu.PreviewKeyDown += FullscreenGrab_KeyDown;
 
-        List<ButtonInfo> regularActions = enabledActions.Where(a => string.IsNullOrEmpty(a.TemplateId)).ToList();
-        List<ButtonInfo> templateActions = enabledActions.Where(a => !string.IsNullOrEmpty(a.TemplateId)).ToList();
+        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;
@@ -542,6 +560,13 @@ 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
@@ -598,6 +623,9 @@ private void UpdateTemplateRegionOverlays(double selLeft, double selTop, double
         TemplateOverlayHost.Children.Clear();
         templateOverlayCanvas.Children.Clear();
 
+        if (CurrentSelectionStyle == FsgSelectionStyle.Freeform)
+            return;
+
         GrabTemplate? template = GetActiveTemplate();
         if (template is null || template.Regions.Count == 0)
             return;
@@ -844,11 +872,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 - 1, topValue - 1, selectBorder.Width, selectBorder.Height);
+        UpdateTemplateRegionOverlays(leftValue, topValue, selectBorder.Width, selectBorder.Height);
     }
 
     private void PlaceGrabFrameInSelectionRect()
@@ -917,253 +945,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) { }
-        TemplateOverlayHost.Children.Clear();
-        templateOverlayCanvas.Children.Clear();
-
-        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);
-
-        UpdateTemplateRegionOverlays(left - 1, top - 1, selectBorder.Width, selectBorder.Height);
+        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));
-
-        TemplateOverlayHost.Children.Clear();
-        templateOverlayCanvas.Children.Clear();
-
-        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));
-
-        // Build the absolute capture rect for template execution (physical screen pixels)
-        System.Windows.Point absoluteWindowPos = this.GetAbsolutePosition();
-        Rect absoluteCaptureRect = new(
-            absoluteWindowPos.X + xDimScaled,
-            absoluteWindowPos.Y + yDimScaled,
-            selectBorder.Width * m.M11,
-            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 is Bitmap cb ? new Bitmap(cb) : null,
-                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 (MenuItem menuItem in GetActionablePostGrabMenuItems(contextMenu))
-            {
-                if (!menuItem.IsChecked || menuItem.Tag is not ButtonInfo action)
-                    continue;
-
-                if (action.ClickEvent == "Insert_Click")
-                {
-                    shouldInsert = true;
-                    continue;
-                }
-
-                PostGrabContext grabContext = new(
-                    Text: TextFromOCR ?? string.Empty,
-                    CaptureRegion: absoluteCaptureRect,
-                    DpiScale: m.M11,
-                    CapturedImage: null,
-                    Language: selectedOcrLang);
-
-                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)
-        {
-            // Only open ETW if we're not doing a web search
-            bool isWebSearch = false;
-            if (NextStepDropDownButton.Flyout is ContextMenu cm)
-            {
-                foreach (MenuItem menuItem in GetActionablePostGrabMenuItems(cm))
-                {
-                    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();
+        await HandleRegionCanvasMouseUpAsync(e);
     }
 
     private void SendToEditTextToggleButton_Click(object sender, RoutedEventArgs e)
@@ -1301,6 +1105,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)
@@ -1316,6 +1127,8 @@ private void Window_Unloaded(object sender, RoutedEventArgs e)
     {
         edgePanTimer.Stop();
         edgePanTimer.Tick -= EdgePanTimer_Tick;
+        windowSelectionTimer.Stop();
+        windowSelectionTimer.Tick -= WindowSelectionTimer_Tick;
 
         DisposeBitmapSource(BackgroundImage);
 
@@ -1326,6 +1139,9 @@ 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)
         {
@@ -1375,6 +1191,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;
@@ -1383,10 +1203,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;
diff --git a/Text-Grab/Views/GrabFrame.xaml b/Text-Grab/Views/GrabFrame.xaml
index 3acf7ae8..a768d5ea 100644
--- a/Text-Grab/Views/GrabFrame.xaml
+++ b/Text-Grab/Views/GrabFrame.xaml
@@ -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>

From 9c50c38251640291e9ac4f4c6256def80ab295c1 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Fri, 6 Mar 2026 16:58:29 -0600
Subject: [PATCH 31/35] Harden barcode bitmap handling

Guard barcode reads against invalid or disposed bitmaps, ensure random-access-stream bitmap copies stay usable after the source stream is released, and add regression coverage for both cases.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 Tests/BarcodeUtilitiesTests.cs          | 44 ++++++++++++++++++
 Text-Grab/Utilities/BarcodeUtilities.cs | 60 +++++++++++++++++++++----
 Text-Grab/Utilities/ImageMethods.cs     | 14 ++++--
 3 files changed, 105 insertions(+), 13 deletions(-)
 create mode 100644 Tests/BarcodeUtilitiesTests.cs

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/Text-Grab/Utilities/BarcodeUtilities.cs b/Text-Grab/Utilities/BarcodeUtilities.cs
index 45cd0928..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,17 @@ 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 (bitmap is null || bitmap.Width <= 0 || bitmap.Height <= 0)
-            return new OcrOutput() { Kind = OcrOutputKind.Barcode, RawOutput = string.Empty };
+        if (!CanReadBitmapDimensions(bitmap))
+            return EmptyBarcodeOutput;
 
         BarcodeReader barcodeReader = new()
         {
             AutoRotate = true,
-            Options = new ZXing.Common.DecodingOptions { TryHarder = true }
+            Options = new DecodingOptions { TryHarder = true }
         };
 
         Result? result = null;
@@ -28,11 +32,21 @@ public static OcrOutput TryToReadBarcodes(Bitmap bitmap)
         try
         {
             result = barcodeReader.Decode(bitmap);
-
         }
-        catch (System.Exception)
+        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)
         {
-            return new OcrOutput() { Kind = OcrOutputKind.Barcode, RawOutput = string.Empty };
+            Debug.WriteLine($"Unable to decode barcode from GDI+ bitmap: {ex.Message}");
+            return EmptyBarcodeOutput;
         }
 
         string resultString = string.Empty;
@@ -47,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()
         {
diff --git a/Text-Grab/Utilities/ImageMethods.cs b/Text-Grab/Utilities/ImageMethods.cs
index e4a908c0..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;
     }
 
@@ -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)

From 2df0c51fd9424824ec3b67eee5d262bb9d8391c6 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Fri, 6 Mar 2026 17:29:41 -0600
Subject: [PATCH 32/35] Improve selection cropping for zoom/pan and add tests

Refactor cropping logic to use a new TryGetBitmapCropRectForSelection method, which accurately maps selection rectangles to bitmap coordinates even when zoom or pan transforms are applied. Remove code that forcibly resets zoom/pan state. Increase selection handle size for better usability. Add unit tests to verify cropping correctness under various transform scenarios.
---
 Tests/FullscreenGrabZoomCaptureTests.cs       | 90 +++++++++++++++++++
 .../Views/FullscreenGrab.SelectionStyles.cs   | 17 ++--
 Text-Grab/Views/FullscreenGrab.xaml.cs        | 87 ++++++++++++++----
 3 files changed, 167 insertions(+), 27 deletions(-)
 create mode 100644 Tests/FullscreenGrabZoomCaptureTests.cs

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/Text-Grab/Views/FullscreenGrab.SelectionStyles.cs b/Text-Grab/Views/FullscreenGrab.SelectionStyles.cs
index 665d8d75..ef17d018 100644
--- a/Text-Grab/Views/FullscreenGrab.SelectionStyles.cs
+++ b/Text-Grab/Views/FullscreenGrab.SelectionStyles.cs
@@ -40,7 +40,7 @@ private enum SelectionInteractionMode
     }
 
     private const double MinimumSelectionSize = 6.0;
-    private const double AdjustHandleSize = 10.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));
@@ -960,14 +960,15 @@ private Rect GetHistoryPositionRect(FullscreenCaptureResult selection)
             Matrix transformToDevice = presentationSource?.CompositionTarget?.TransformToDevice ?? Matrix.Identity;
             Rect selectionRect = GetCurrentSelectionRect();
 
-            int cropX = Math.Max(0, (int)Math.Round(selectionRect.Left * transformToDevice.M11));
-            int cropY = Math.Max(0, (int)Math.Round(selectionRect.Top * transformToDevice.M22));
-            int cropW = Math.Min((int)Math.Round(selectionRect.Width * transformToDevice.M11), backgroundBitmap.PixelWidth - cropX);
-            int cropH = Math.Min((int)Math.Round(selectionRect.Height * transformToDevice.M22), backgroundBitmap.PixelHeight - cropY);
-
-            if (cropW > 0 && cropH > 0)
+            if (TryGetBitmapCropRectForSelection(
+                selectionRect,
+                transformToDevice,
+                BackgroundImage.RenderTransform,
+                backgroundBitmap.PixelWidth,
+                backgroundBitmap.PixelHeight,
+                out Int32Rect cropRect))
             {
-                CroppedBitmap croppedBitmap = new(backgroundBitmap, new Int32Rect(cropX, cropY, cropW, cropH));
+                CroppedBitmap croppedBitmap = new(backgroundBitmap, cropRect);
                 croppedBitmap.Freeze();
                 return croppedBitmap;
             }
diff --git a/Text-Grab/Views/FullscreenGrab.xaml.cs b/Text-Grab/Views/FullscreenGrab.xaml.cs
index d8cf5f2e..fd60f535 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml.cs
+++ b/Text-Grab/Views/FullscreenGrab.xaml.cs
@@ -836,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)
@@ -893,14 +888,17 @@ private void PlaceGrabFrameInSelectionRect()
         if (BackgroundImage.Source is BitmapSource backgroundBitmap)
         {
             Matrix m = PresentationSource.FromVisual(this).CompositionTarget.TransformToDevice;
-            int cropX = Math.Max(0, (int)(Canvas.GetLeft(selectBorder) * m.M11));
-            int cropY = Math.Max(0, (int)(Canvas.GetTop(selectBorder) * m.M22));
-            int cropW = Math.Min((int)(selectBorder.Width * m.M11), backgroundBitmap.PixelWidth - cropX);
-            int cropH = Math.Min((int)(selectBorder.Height * m.M22), backgroundBitmap.PixelHeight - cropY);
-
-            if (cropW > 0 && cropH > 0)
+            Rect selectionRect = GetCurrentSelectionRect();
+
+            if (TryGetBitmapCropRectForSelection(
+                selectionRect,
+                m,
+                BackgroundImage.RenderTransform,
+                backgroundBitmap.PixelWidth,
+                backgroundBitmap.PixelHeight,
+                out Int32Rect cropRect))
             {
-                CroppedBitmap croppedBitmap = new(backgroundBitmap, new Int32Rect(cropX, cropY, cropW, cropH));
+                CroppedBitmap croppedBitmap = new(backgroundBitmap, cropRect);
                 croppedBitmap.Freeze();
                 grabFrame = new GrabFrame(croppedBitmap);
             }
@@ -1407,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)
@@ -1491,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();

From d28f1b45e55b18632e600dd93ffeb5f16a4675a9 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 7 Mar 2026 01:45:27 +0000
Subject: [PATCH 33/35] Initial plan


From 28a021d685279d0adc153c8ebffbd9b8fff688d4 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 7 Mar 2026 01:50:35 +0000
Subject: [PATCH 34/35] Fix 5 review comments: shortcut cap, ItemsDictionary
 clear, null ItemsSource, duplicate handlers, Freeform key hint

Co-authored-by: TheJoeFin <7809853+TheJoeFin@users.noreply.github.com>
---
 Text-Grab/Controls/InlineChipElement.cs       | 14 ++++++++++++--
 Text-Grab/Controls/InlinePickerRichTextBox.cs |  2 +-
 Text-Grab/Views/FullscreenGrab.xaml           |  2 +-
 Text-Grab/Views/FullscreenGrab.xaml.cs        |  2 +-
 Text-Grab/Views/QuickSimpleLookup.xaml.cs     |  1 +
 5 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/Text-Grab/Controls/InlineChipElement.cs b/Text-Grab/Controls/InlineChipElement.cs
index da12f279..beab9d6b 100644
--- a/Text-Grab/Controls/InlineChipElement.cs
+++ b/Text-Grab/Controls/InlineChipElement.cs
@@ -31,6 +31,8 @@ public string Value
 
     public event EventHandler? RemoveRequested;
 
+    private Button? _removeButton;
+
     static InlineChipElement()
     {
         DefaultStyleKeyProperty.OverrideMetadata(
@@ -42,7 +44,15 @@ public override void OnApplyTemplate()
     {
         base.OnApplyTemplate();
 
-        if (GetTemplateChild(PartRemoveButton) is Button removeButton)
-            removeButton.Click += (s, e) => RemoveRequested?.Invoke(this, EventArgs.Empty);
+        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/InlinePickerRichTextBox.cs b/Text-Grab/Controls/InlinePickerRichTextBox.cs
index a3c34dbe..0957745d 100644
--- a/Text-Grab/Controls/InlinePickerRichTextBox.cs
+++ b/Text-Grab/Controls/InlinePickerRichTextBox.cs
@@ -50,7 +50,7 @@ public class InlinePickerRichTextBox : RichTextBox
 
     public IEnumerable<InlinePickerItem> ItemsSource
     {
-        get => (IEnumerable<InlinePickerItem>)GetValue(ItemsSourceProperty);
+        get => (IEnumerable<InlinePickerItem>?)GetValue(ItemsSourceProperty) ?? [];
         set => SetValue(ItemsSourceProperty, value);
     }
 
diff --git a/Text-Grab/Views/FullscreenGrab.xaml b/Text-Grab/Views/FullscreenGrab.xaml
index 90717c49..35902a56 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml
+++ b/Text-Grab/Views/FullscreenGrab.xaml
@@ -95,7 +95,7 @@
                             x:Name="FreeformSelectionMenuItem"
                             Click="SelectionStyleMenuItem_Click"
                             Header="Freeform - Draw any shape"
-                            InputGestureText="P"
+                            InputGestureText="D"
                             IsCheckable="True"
                             Tag="Freeform" />
                         <MenuItem
diff --git a/Text-Grab/Views/FullscreenGrab.xaml.cs b/Text-Grab/Views/FullscreenGrab.xaml.cs
index fd60f535..78ffa652 100644
--- a/Text-Grab/Views/FullscreenGrab.xaml.cs
+++ b/Text-Grab/Views/FullscreenGrab.xaml.cs
@@ -428,7 +428,7 @@ private void AddPostGrabActionMenuItem(ContextMenu contextMenu, ButtonInfo actio
             Tag = action,
             IsChecked = isChecked,
             StaysOpenOnClick = stayOpen,
-            InputGestureText = $"Ctrl+{shortcutIndex}"
+            InputGestureText = shortcutIndex <= 9 ? $"Ctrl+{shortcutIndex}" : string.Empty
         };
 
         menuItem.Click += PostActionMenuItem_Click;
diff --git a/Text-Grab/Views/QuickSimpleLookup.xaml.cs b/Text-Grab/Views/QuickSimpleLookup.xaml.cs
index 09a8ed18..936e83f2 100644
--- a/Text-Grab/Views/QuickSimpleLookup.xaml.cs
+++ b/Text-Grab/Views/QuickSimpleLookup.xaml.cs
@@ -732,6 +732,7 @@ private async Task LoadDataGridContent(string csvToOpenPath)
             PopulateSampleData();
 
         MainDataGrid.ItemsSource = null;
+        ItemsDictionary.Clear();
 
         ItemsDictionary.AddRange(ParseStringToRows(contentToParse, true));
         lookupItems = [.. ItemsDictionary];

From 695273966d8f9b58fa55e0095bd71dd07a5030d3 Mon Sep 17 00:00:00 2001
From: Joe Finney <josephfinney@LIVE.COM>
Date: Fri, 6 Mar 2026 20:15:17 -0600
Subject: [PATCH 35/35] Switch pattern match mode selection to RadioButtons

Replaced ComboBox with a set of RadioButtons for selecting the pattern match mode in the dialog, improving visibility and usability. Updated event handling and logic to support the new selection method. Increased dialog height to fit the revised layout.
---
 .../Controls/PatternMatchModeDialog.xaml      | 47 +++++++++++++------
 .../Controls/PatternMatchModeDialog.xaml.cs   |  7 +--
 2 files changed, 37 insertions(+), 17 deletions(-)

diff --git a/Text-Grab/Controls/PatternMatchModeDialog.xaml b/Text-Grab/Controls/PatternMatchModeDialog.xaml
index 442428bc..8dc28a7d 100644
--- a/Text-Grab/Controls/PatternMatchModeDialog.xaml
+++ b/Text-Grab/Controls/PatternMatchModeDialog.xaml
@@ -7,7 +7,7 @@
     xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
     Title="Pattern Match Options"
     Width="420"
-    Height="320"
+    Height="450"
     MinWidth="380"
     MinHeight="280"
     WindowStartupLocation="CenterOwner"
@@ -32,29 +32,48 @@
 
         <StackPanel Grid.Row="1" Margin="12">
             <TextBlock
+                x:Name="PatternNameLabel"
                 Margin="0,0,0,8"
                 FontWeight="SemiBold"
-                x:Name="PatternNameLabel"
                 Text="Pattern:" />
 
             <TextBlock Margin="0,0,0,4" Text="Match Mode:" />
-            <ComboBox
-                x:Name="MatchModeComboBox"
-                Margin="0,0,0,12"
-                SelectedIndex="0"
-                SelectionChanged="MatchModeComboBox_SelectionChanged">
-                <ComboBoxItem Content="First Match" Tag="first" />
-                <ComboBoxItem Content="Last Match" Tag="last" />
-                <ComboBoxItem Content="All Matches" Tag="all" />
-                <ComboBoxItem Content="Specific Match(es)" Tag="nth" />
-            </ComboBox>
+            <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">
+            <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">
+            <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"
diff --git a/Text-Grab/Controls/PatternMatchModeDialog.xaml.cs b/Text-Grab/Controls/PatternMatchModeDialog.xaml.cs
index 47b80e7f..8d0f4de7 100644
--- a/Text-Grab/Controls/PatternMatchModeDialog.xaml.cs
+++ b/Text-Grab/Controls/PatternMatchModeDialog.xaml.cs
@@ -29,7 +29,7 @@ public PatternMatchModeDialog(string patternId, string patternName)
         PatternNameLabel.Text = $"Pattern: {patternName}";
     }
 
-    private void MatchModeComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
+    private void MatchModeRadioButton_Checked(object sender, RoutedEventArgs e)
     {
         if (SeparatorPanel == null || IndicesPanel == null)
             return;
@@ -96,8 +96,9 @@ private void HideIndicesError()
 
     private string GetSelectedMode()
     {
-        if (MatchModeComboBox.SelectedItem is ComboBoxItem item)
-            return item.Tag?.ToString() ?? "first";
+        if (MatchModePanel?.Children.OfType<RadioButton>().FirstOrDefault(button => button.IsChecked == true) is RadioButton button)
+            return button.Tag?.ToString() ?? "first";
+
         return "first";
     }