Merge pull request #37 from RuntimeRascal/feat/add-text-tool

Feat/add text tool

Author: RuntimeRascal

CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to GhostDraw will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## v1.0.17
+
+### Added
+- **Text Tool**
+  - Added a lock-mode-only Text tool (hotkey `T`) with multi-line entry and outside-click commit; text respects brush color/size and stays non-editable after commit.
+  - Hardened input safety during text sessions: only activation hotkey, `F1`, and `ESC` remain active; other GhostDraw shortcuts aren’t triggered or suppressed while typing.
+  - Integrated text into history/undo/clear and eraser; multi-monitor overlays record committed text with proper overlay IDs.
+
+### Changed
+- Help modal now show's tool usage instruction and is re-styled.
+
+### Fixed
+- 2 hotkey presses required to activate draw mode after startup.
+- Ghost drawings briefly appearing on re-activations.
 
 ## v1.0.16
 

Installer/GhostDraw.Installer.wixproj

@@ -1,6 +1,6 @@
 <Project Sdk="WixToolset.Sdk/4.0.5">
   <PropertyGroup>
-    <Version Condition="'$(Version)' == ''">1.0.16</Version>
+    <Version Condition="'$(Version)' == ''">1.0.17</Version>
     <OutputName>GhostDrawSetup-$(Version)</OutputName>
     <OutputType>Package</OutputType>
     <Platform>x64</Platform>

Src/GhostDraw/App.xaml.cs

@@ -80,6 +80,7 @@ protected override void OnStartup(StartupEventArgs e)
             _keyboardHook.EraserToolPressed += OnEraserToolPressed;
             _keyboardHook.RectangleToolPressed += OnRectangleToolPressed;
             _keyboardHook.CircleToolPressed += OnCircleToolPressed;
+            _keyboardHook.TextToolPressed += OnTextToolPressed;
             _keyboardHook.HelpPressed += OnHelpPressed;
             _keyboardHook.ScreenshotFullPressed += OnScreenshotFullPressed;
             _keyboardHook.UndoPressed += OnUndoPressed;
@@ -359,6 +360,23 @@ private void OnCircleToolPressed(object? sender, EventArgs e)
         }
     }
 
+    private void OnTextToolPressed(object? sender, EventArgs e)
+    {
+        try
+        {
+            // Only switch to text tool if drawing mode is active
+            if (_drawingManager?.IsDrawingMode == true)
+            {
+                _logger?.LogInformation("T pressed - selecting text tool");
+                _drawingManager?.SetTextTool();
+            }
+        }
+        catch (Exception ex)
+        {
+            _exceptionHandler?.HandleException(ex, "Text tool handler");
+        }
+    }
+
     private void OnHelpPressed(object? sender, EventArgs e)
     {
         try

Src/GhostDraw/Core/DrawTool.cs

@@ -36,5 +36,10 @@ public enum DrawTool
     /// <summary>
     /// Arrow tool - click two points to draw a line with an arrowhead
     /// </summary>
-    Arrow
+    Arrow,
+
+    /// <summary>
+    /// Text tool - click to start typing, click outside to commit
+    /// </summary>
+    Text
 }

Src/GhostDraw/Core/GlobalKeyboardHook.cs

@@ -19,6 +19,7 @@ public class GlobalKeyboardHook : IDisposable
     private const int VK_E = 0x45;         // 69 - 'E' key for eraser tool
     private const int VK_U = 0x55;         // 85 - 'U' key for rectangle tool
     private const int VK_C = 0x43;         // 67 - 'C' key for circle tool
+    private const int VK_T = 0x54;         // 84 - 'T' key for text tool
     private const int VK_F1 = 0x70;        // 112 - 'F1' key for help
     private const int VK_S = 0x53;         // 83 - 'S' key for screenshot (Ctrl+S only)
     private const int VK_Z = 0x5A;         // 90 - 'Z' key for undo (Ctrl+Z only)
@@ -42,6 +43,7 @@ public class GlobalKeyboardHook : IDisposable
     public event EventHandler? EraserToolPressed;
     public event EventHandler? RectangleToolPressed;
     public event EventHandler? CircleToolPressed;
+    public event EventHandler? TextToolPressed;
     public event EventHandler? HelpPressed;
     public event EventHandler? ScreenshotFullPressed;
     public event EventHandler? UndoPressed;
@@ -59,6 +61,9 @@ public class GlobalKeyboardHook : IDisposable
     // Drawing mode state - used to determine if we should suppress keys
     private volatile bool _isDrawingModeActive = false;
 
+    // Text entry session state - when active, GhostDraw must not steal/suppress typing keys
+    private volatile bool _isTextSessionActive = false;
+
     public GlobalKeyboardHook(ILogger<GlobalKeyboardHook> logger)
     {
         _logger = logger;
@@ -218,6 +223,24 @@ private nint HookCallback(int nCode, nint wParam, nint lParam)
                     EscapePressed?.Invoke(this, EventArgs.Empty);
                 }
 
+                // While a text session is active, do not fire tool/action shortcuts
+                // and do not suppress keys needed for typing. Still allow:
+                // - ESC (emergency exit)
+                // - F1 (help)
+                // - activation hotkey (HotkeyPressed/Released)
+                if (_isTextSessionActive)
+                {
+                    if (vkCode == VK_F1 && isKeyDown)
+                    {
+                        _logger.LogDebug("F1 key pressed - help request (text session active)");
+                        HelpPressed?.Invoke(this, EventArgs.Empty);
+                    }
+
+                    // Skip the rest of GhostDraw key handling (Delete/Ctrl+Z/Ctrl+S/tool keys)
+                    // so normal typing works inside the overlay text box.
+                    goto TrackHotkeyState;
+                }
+
                 // Check for Delete key press (clear canvas - only when drawing mode is active)
                 if ((vkCode == VK_DELETE) && isKeyDown && _isDrawingModeActive)
                 {
@@ -275,6 +298,13 @@ private nint HookCallback(int nCode, nint wParam, nint lParam)
                     CircleToolPressed?.Invoke(this, EventArgs.Empty);
                 }
 
+                // Check for T key press (text tool)
+                if (vkCode == VK_T && isKeyDown)
+                {
+                    _logger.LogDebug("T key pressed - text tool request");
+                    TextToolPressed?.Invoke(this, EventArgs.Empty);
+                }
+
                 // Check for F1 key press (help)
                 if (vkCode == VK_F1 && isKeyDown)
                 {
@@ -320,6 +350,7 @@ private nint HookCallback(int nCode, nint wParam, nint lParam)
                 }
 
                 // Track hotkey state
+            TrackHotkeyState:
                 if (_hotkeyVKs.Contains(vkCode))
                 {
                     _keyStates[vkCode] = isKeyDown;
@@ -402,6 +433,26 @@ public void SetDrawingModeActive(bool isActive)
         }
     }
 
+    /// <summary>
+    /// Sets whether a text entry session is active. When active, GhostDraw won't trigger
+    /// most shortcuts (tool keys, clear, undo, screenshot) and won't suppress typing keys.
+    /// </summary>
+    public void SetTextSessionActive(bool isActive)
+    {
+        _isTextSessionActive = isActive;
+        _logger.LogInformation("Text session active: {IsActive}", isActive);
+    }
+
+    // Internal helpers for unit tests
+    public static bool ShouldSuppressDelete(bool isKeyDown, bool isDrawingModeActive, bool isTextSessionActive)
+        => isKeyDown && isDrawingModeActive && !isTextSessionActive;
+
+    public static bool ShouldSuppressCtrlS(bool isKeyDown, bool isControlPressed, bool isDrawingModeActive, bool isTextSessionActive)
+        => isKeyDown && isControlPressed && isDrawingModeActive && !isTextSessionActive;
+
+    public static bool ShouldSuppressCtrlZ(bool isKeyDown, bool isControlPressed, bool isDrawingModeActive, bool isTextSessionActive)
+        => isKeyDown && isControlPressed && isDrawingModeActive && !isTextSessionActive;
+
     // P/Invoke declarations
     private delegate nint LowLevelKeyboardProc(int nCode, nint wParam, nint lParam);
 

Src/GhostDraw/Core/ServiceConfiguration.cs

@@ -67,6 +67,7 @@ public static ServiceProvider ConfigureServices()
         services.AddTransient<GhostDraw.Tools.EraserTool>();
         services.AddTransient<GhostDraw.Tools.RectangleTool>();
         services.AddTransient<GhostDraw.Tools.CircleTool>();
+        services.AddTransient<GhostDraw.Tools.TextTool>();
 
         services.AddTransient<OverlayWindow>();
         services.AddSingleton<MultiOverlayWindowOrchestrator>();

Src/GhostDraw/GhostDraw.csproj

@@ -8,7 +8,7 @@
     <UseWPF>true</UseWPF>
     <UseWindowsForms>true</UseWindowsForms>
     <ApplicationIcon>Assets\favicon.ico</ApplicationIcon>
-    <Version>1.0.16</Version>
+    <Version>1.0.17</Version>
     <EnableWindowsTargeting>true</EnableWindowsTargeting>
   </PropertyGroup>
 

Src/GhostDraw/Managers/DrawingManager.cs

@@ -1,3 +1,5 @@
+using System.Threading.Tasks;
+using System.Windows.Threading;
 using GhostDraw.Core;
 using GhostDraw.Services;
 using GhostDraw.Views;
@@ -12,6 +14,7 @@ public class DrawingManager
     private readonly AppSettingsService _appSettings;
     private readonly ScreenshotService _screenshotService;
     private readonly GlobalKeyboardHook _keyboardHook;
+    private readonly Dispatcher _dispatcher;
     private bool _isDrawingLocked = false;
 
     // Delay in milliseconds before re-showing overlay after opening snipping tool
@@ -28,15 +31,23 @@ public DrawingManager(ILogger<DrawingManager> logger, IOverlayWindow overlayWind
         _appSettings = appSettings;
         _screenshotService = screenshotService;
         _keyboardHook = keyboardHook;
+        _dispatcher = System.Windows.Application.Current?.Dispatcher ?? Dispatcher.CurrentDispatcher;
 
-        // Initialize lock mode state from saved settings
-        _isDrawingLocked = _appSettings.CurrentSettings.LockDrawingMode;
+        // LockDrawingMode controls behavior (toggle vs hold) but the locked state should start off
+        _isDrawingLocked = false;
 
-        _logger.LogDebug("DrawingManager initialized - LockDrawingMode={LockMode}", _isDrawingLocked);
+        _logger.LogDebug("DrawingManager initialized - LockDrawingModeBehavior={LockMode} StartingLocked={IsLocked}",
+            _appSettings.CurrentSettings.LockDrawingMode, _isDrawingLocked);
     }
 
     public void EnableDrawing()
     {
+        if (!_dispatcher.CheckAccess())
+        {
+            _dispatcher.BeginInvoke(new Action(EnableDrawing));
+            return;
+        }
+
         try
         {
             var settings = _appSettings.CurrentSettings;
@@ -49,7 +60,7 @@ public void EnableDrawing()
                     _logger.LogInformation("Toggling drawing mode OFF (was locked)");
                     _isDrawingLocked = false;
                     _overlayWindow.DisableDrawing();
-                    _overlayWindow.Hide();
+                    ScheduleOverlayHide();
 
                     // Notify hook that drawing mode is inactive
                     _keyboardHook.SetDrawingModeActive(false);
@@ -90,7 +101,7 @@ public void EnableDrawing()
             try
             {
                 _overlayWindow.DisableDrawing();
-                _overlayWindow.Hide();
+                ScheduleOverlayHide();
                 _isDrawingLocked = false;
                 _keyboardHook.SetDrawingModeActive(false);
             }
@@ -104,6 +115,12 @@ public void EnableDrawing()
 
     public void DisableDrawing()
     {
+        if (!_dispatcher.CheckAccess())
+        {
+            _dispatcher.BeginInvoke(new Action(DisableDrawing));
+            return;
+        }
+
         try
         {
             var settings = _appSettings.CurrentSettings;
@@ -120,7 +137,7 @@ public void DisableDrawing()
             // Hold mode: disable when hotkey is released
             _logger.LogInformation("Disabling drawing mode (hold released)");
             _overlayWindow.DisableDrawing();
-            _overlayWindow.Hide();
+            ScheduleOverlayHide();
 
             // Notify hook that drawing mode is inactive
             _keyboardHook.SetDrawingModeActive(false);
@@ -146,6 +163,12 @@ public void DisableDrawing()
 
     public void ForceDisableDrawing()
     {
+        if (!_dispatcher.CheckAccess())
+        {
+            _dispatcher.BeginInvoke(new Action(ForceDisableDrawing));
+            return;
+        }
+
         try
         {
             _logger.LogInformation("ESC pressed - checking help visibility");
@@ -159,7 +182,7 @@ public void ForceDisableDrawing()
                 _logger.LogDebug("Force disabling drawing mode");
                 _isDrawingLocked = false;
                 _overlayWindow.DisableDrawing();
-                _overlayWindow.Hide();
+                ScheduleOverlayHide();
 
                 // Notify hook that drawing mode is inactive
                 _keyboardHook.SetDrawingModeActive(false);
@@ -194,12 +217,18 @@ public void ForceDisableDrawing()
     public void DisableDrawingMode()
     {
         // Public method for emergency state reset
+        if (!_dispatcher.CheckAccess())
+        {
+            _dispatcher.BeginInvoke(new Action(DisableDrawingMode));
+            return;
+        }
+
         try
         {
             _logger.LogWarning("DisableDrawingMode called (likely from emergency reset)");
             _isDrawingLocked = false;
             _overlayWindow.DisableDrawing();
-            _overlayWindow.Hide();
+            ScheduleOverlayHide();
 
             // Notify hook that drawing mode is inactive
             _keyboardHook.SetDrawingModeActive(false);
@@ -211,6 +240,31 @@ public void DisableDrawingMode()
         }
     }
 
+    private void ScheduleOverlayHide()
+    {
+        // Allow the cleared canvas to render before hiding to avoid ghosting when reactivating.
+        if (_overlayWindow is OverlayWindow or MultiOverlayWindowOrchestrator)
+        {
+            _dispatcher.InvokeAsync(async () =>
+            {
+                try
+                {
+                    await Task.Delay(30); // ~2 frames at 60fps
+                    _overlayWindow.Hide();
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogDebug(ex, "Delayed overlay hide failed (safe to ignore)");
+                }
+            }, DispatcherPriority.Background);
+        }
+        else
+        {
+            // Tests use mock overlay implementations; hide synchronously so verifications succeed.
+            _overlayWindow.Hide();
+        }
+    }
+
     /// <summary>
     /// Toggles between Pen and Line drawing tools
     /// </summary>
@@ -386,6 +440,31 @@ public void SetCircleTool()
         }
     }
 
+    /// <summary>
+    /// Sets the active tool to Text
+    /// </summary>
+    public void SetTextTool()
+    {
+        try
+        {
+            if (_overlayWindow.IsVisible)
+            {
+                _appSettings.SetActiveTool(DrawTool.Text);
+                _overlayWindow.OnToolChanged(DrawTool.Text);
+                _logger.LogInformation("Tool set to Text");
+            }
+            else
+            {
+                _logger.LogDebug("SetTextTool ignored - overlay not visible");
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to set text tool");
+            // Don't re-throw - not critical
+        }
+    }
+
     /// <summary>
     /// Toggles the help popup with keyboard shortcuts
     /// </summary>

Src/GhostDraw/Tools/EraserTool.cs

@@ -219,6 +219,22 @@ private void EraseAtPosition(Point position, Canvas canvas)
                         _logger.LogDebug(ex, "Failed to compute Path bounds for erasing");
                     }
                 }
+                else if (element is TextBlock textBlock)
+                {
+                    double left = Canvas.GetLeft(textBlock);
+                    double top = Canvas.GetTop(textBlock);
+                    double width = textBlock.ActualWidth > 0 ? textBlock.ActualWidth : textBlock.Width;
+                    double height = textBlock.ActualHeight > 0 ? textBlock.ActualHeight : textBlock.FontSize * 1.5;
+
+                    if (!double.IsNaN(left) && !double.IsNaN(top) && width > 0 && height > 0)
+                    {
+                        Rect textRect = new Rect(left, top, width, height);
+                        if (eraserRect.IntersectsWith(textRect))
+                        {
+                            shouldErase = true;
+                        }
+                    }
+                }
 
                 if (shouldErase)
                 {