Merge pull request #19 from RuntimeRascal/copilot/add-eraser-tool-functionality

Add eraser tool with E/P key toggle and refactor to tool-based architecture

Author: RuntimeRascal

CHANGELOG.md

@@ -5,6 +5,22 @@ 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.6
+
+### Added
+- **Eraser Tool** - Remove drawing objects underneath the cursor
+  - Press `E` to activate Eraser tool
+  - Click and drag to erase drawings interactively
+  - Eraser size adjusts with mouse wheel (same as brush thickness)
+  - Intelligent intersection detection for precise erasing
+  - Works with both polylines (pen strokes) and lines (straight line tool)
+  - Custom eraser cursor with visual feedback
+- **Improved Code Quality**
+  - Enhanced tool interface consistency
+
+### Fixed
+- LineTool's `OnDeactivated` method now properly resets state without calling non-existent method
+
 ## v1.0.5
 
 ### Added
@@ -115,4 +131,3 @@ When adding new features or fixes:
 
 ### Fixed
 - Issue description and what was fixed
-```

Installer/GhostDraw.Installer.wixproj

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

Src/GhostDraw/App.xaml.cs

@@ -76,6 +76,7 @@ protected override void OnStartup(StartupEventArgs e)
             _keyboardHook.ClearCanvasPressed += OnClearCanvasPressed;
             _keyboardHook.PenToolPressed += OnPenToolPressed;
             _keyboardHook.LineToolPressed += OnLineToolPressed;
+            _keyboardHook.EraserToolPressed += OnEraserToolPressed;
             _keyboardHook.HelpPressed += OnHelpPressed;
             _keyboardHook.Start();
 
@@ -288,6 +289,23 @@ private void OnLineToolPressed(object? sender, EventArgs e)
         }
     }
 
+    private void OnEraserToolPressed(object? sender, EventArgs e)
+    {
+        try
+        {
+            // Only switch to eraser tool if drawing mode is active
+            if (_drawingManager?.IsDrawingMode == true)
+            {
+                _logger?.LogInformation("E pressed - selecting eraser tool");
+                _drawingManager?.SetEraserTool();
+            }
+        }
+        catch (Exception ex)
+        {
+            _exceptionHandler?.HandleException(ex, "Eraser tool handler");
+        }
+    }
+
     private void OnHelpPressed(object? sender, EventArgs e)
     {
         try

Src/GhostDraw/Core/DrawTool.cs

@@ -16,5 +16,10 @@ public enum DrawTool
     /// <summary>
     /// Straight line tool - click two points to draw a line
     /// </summary>
-    Line
+    Line,
+    
+    /// <summary>
+    /// Eraser tool - removes drawing objects underneath the cursor
+    /// </summary>
+    Eraser
 }

Src/GhostDraw/Core/GlobalKeyboardHook.cs

@@ -15,6 +15,7 @@ public class GlobalKeyboardHook : IDisposable
     private const int VK_R = 0x52;         // 82 - 'R' key for clear canvas
     private const int VK_L = 0x4C;         // 76 - 'L' key for line tool
     private const int VK_P = 0x50;         // 80 - 'P' key for pen tool
+    private const int VK_E = 0x45;         // 69 - 'E' key for eraser tool
     private const int VK_F1 = 0x70;        // 112 - 'F1' key for help
 
     private readonly ILogger<GlobalKeyboardHook> _logger;
@@ -30,6 +31,7 @@ public class GlobalKeyboardHook : IDisposable
     public event EventHandler? ClearCanvasPressed;
     public event EventHandler? PenToolPressed;
     public event EventHandler? LineToolPressed;
+    public event EventHandler? EraserToolPressed;
     public event EventHandler? HelpPressed;
 
     // NEW: Raw key events for recorder
@@ -210,6 +212,13 @@ private nint HookCallback(int nCode, nint wParam, nint lParam)
                     PenToolPressed?.Invoke(this, EventArgs.Empty);
                 }
 
+                // Check for E key press (eraser tool)
+                if (vkCode == VK_E && isKeyDown)
+                {
+                    _logger.LogDebug("E key pressed - eraser tool request");
+                    EraserToolPressed?.Invoke(this, EventArgs.Empty);
+                }
+
                 // Check for F1 key press (help)
                 if (vkCode == VK_F1 && isKeyDown)
                 {

Src/GhostDraw/Core/ServiceConfiguration.cs

@@ -57,6 +57,12 @@ public static ServiceProvider ConfigureServices()
         // Register application services (order matters for dependencies)
         services.AddSingleton<AppSettingsService>();
         services.AddSingleton<CursorHelper>();
+        
+        // Register drawing tools
+        services.AddSingleton<GhostDraw.Tools.PenTool>();
+        services.AddSingleton<GhostDraw.Tools.LineTool>();
+        services.AddSingleton<GhostDraw.Tools.EraserTool>();
+        
         services.AddSingleton<OverlayWindow>();
         services.AddSingleton<GlobalKeyboardHook>();
         services.AddSingleton<DrawingManager>();

Src/GhostDraw/GhostDraw.csproj

@@ -8,7 +8,7 @@
     <UseWPF>true</UseWPF>
     <UseWindowsForms>true</UseWindowsForms>
     <ApplicationIcon>Assets\favicon.ico</ApplicationIcon>
-    <Version>1.0.5</Version>
+    <Version>1.0.6</Version>
   </PropertyGroup>
 
   <ItemGroup>

Src/GhostDraw/Helpers/CursorHelper.cs

@@ -147,6 +147,118 @@ public WpfCursor CreateColoredPencilCursor(string tipColorHex)
         }
     }
 
+    /// <summary>
+    /// Creates an eraser cursor
+    /// </summary>
+    /// <returns>Custom eraser cursor</returns>
+    public WpfCursor CreateEraserCursor()
+    {
+        lock (_cursorLock)
+        {
+            if (_disposed)
+            {
+                _logger.LogWarning("CreateEraserCursor called on disposed CursorHelper");
+                return WpfCursors.Cross;
+            }
+
+            try
+            {
+                _logger.LogDebug("Creating eraser cursor");
+
+                // Destroy previous cursor handle to prevent leaks
+                if (_currentCursorHandle != nint.Zero)
+                {
+                    try
+                    {
+                        DestroyCursor(_currentCursorHandle);
+                        _logger.LogDebug("Destroyed previous cursor handle");
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError(ex, "Failed to destroy previous cursor handle");
+                    }
+                    _currentCursorHandle = nint.Zero;
+                }
+
+                // Create a bitmap for the cursor (32x32 pixels)
+                int size = 32;
+                using (Bitmap bitmap = new Bitmap(size, size))
+                using (Graphics g = Graphics.FromImage(bitmap))
+                {
+                    g.SmoothingMode = SmoothingMode.AntiAlias;
+                    g.Clear(Color.Transparent);
+
+                    // Draw eraser shape (rectangle with slight perspective)
+                    int eraserWidth = 16;
+                    int eraserHeight = 12;
+                    int eraserLeft = (size - eraserWidth) / 2;
+                    int eraserTop = (size - eraserHeight) / 2 - 2;
+
+                    // Draw eraser body (pink/beige color like a traditional eraser)
+                    using (LinearGradientBrush eraserBrush = new LinearGradientBrush(
+                        new Rectangle(eraserLeft, eraserTop, eraserWidth, eraserHeight),
+                        Color.FromArgb(255, 220, 220),
+                        Color.FromArgb(255, 180, 180),
+                        45f))
+                    {
+                        g.FillRectangle(eraserBrush, eraserLeft, eraserTop, eraserWidth, eraserHeight);
+                    }
+
+                    // Draw eraser outline
+                    using (Pen outlinePen = new Pen(Color.Black, 1.5f))
+                    {
+                        g.DrawRectangle(outlinePen, eraserLeft, eraserTop, eraserWidth, eraserHeight);
+                    }
+
+                    // Draw diagonal lines to give texture
+                    using (Pen texturePen = new Pen(Color.FromArgb(100, 200, 150, 150), 1))
+                    {
+                        for (int i = 0; i < 3; i++)
+                        {
+                            int offset = i * 5;
+                            g.DrawLine(texturePen, 
+                                eraserLeft + offset, eraserTop, 
+                                eraserLeft + offset + 6, eraserTop + eraserHeight);
+                        }
+                    }
+
+                    // Add highlight for depth
+                    using (Pen highlight = new Pen(Color.White, 1))
+                    {
+                        g.DrawLine(highlight, eraserLeft + 2, eraserTop + 2, eraserLeft + eraserWidth - 4, eraserTop + 2);
+                    }
+
+                    // Draw small "eraser particles" below to indicate erasing action
+                    using (SolidBrush particleBrush = new SolidBrush(Color.FromArgb(150, 180, 180, 180)))
+                    {
+                        g.FillEllipse(particleBrush, eraserLeft + 3, eraserTop + eraserHeight + 2, 2, 2);
+                        g.FillEllipse(particleBrush, eraserLeft + 8, eraserTop + eraserHeight + 4, 2, 2);
+                        g.FillEllipse(particleBrush, eraserLeft + 12, eraserTop + eraserHeight + 3, 2, 2);
+                    }
+
+                    // Convert bitmap to cursor with hotspot at center
+                    nint hCursor = CreateCursorFromBitmap(bitmap, size / 2, size / 2);
+
+                    if (hCursor != nint.Zero)
+                    {
+                        _currentCursorHandle = hCursor;
+                        _logger.LogDebug("Successfully created eraser cursor (handle: {Handle})", hCursor);
+
+                        return System.Windows.Interop.CursorInteropHelper.Create(new SafeCursorHandle(hCursor));
+                    }
+                }
+
+                _logger.LogWarning("Failed to create eraser cursor, returning default");
+                return WpfCursors.Cross;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error creating eraser cursor, using default");
+                return WpfCursors.Cross;
+            }
+        }
+    }
+
     /// <summary>
     /// Creates a crosshair cursor with color indicator for the Line tool
     /// </summary>

Src/GhostDraw/Managers/DrawingManager.cs

@@ -240,6 +240,31 @@ public void SetLineTool()
         }
     }
 
+    /// <summary>
+    /// Sets the active tool to Eraser
+    /// </summary>
+    public void SetEraserTool()
+    {
+        try
+        {
+            if (_overlayWindow.IsVisible)
+            {
+                _appSettings.SetActiveTool(DrawTool.Eraser);
+                _overlayWindow.OnToolChanged(DrawTool.Eraser);
+                _logger.LogInformation("Tool set to Eraser");
+            }
+            else
+            {
+                _logger.LogDebug("SetEraserTool ignored - overlay not visible");
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to set eraser tool");
+            // Don't re-throw - not critical
+        }
+    }
+
     /// <summary>
     /// Shows the help popup with keyboard shortcuts
     /// </summary>