feat: add line tool

Author: RuntimeRascal

Src/GhostDraw/App.xaml.cs

@@ -74,6 +74,9 @@ protected override void OnStartup(StartupEventArgs e)
             _keyboardHook.HotkeyReleased += OnHotkeyReleased;
             _keyboardHook.EscapePressed += OnEscapePressed;
             _keyboardHook.ClearCanvasPressed += OnClearCanvasPressed;
+            _keyboardHook.PenToolPressed += OnPenToolPressed;
+            _keyboardHook.LineToolPressed += OnLineToolPressed;
+            _keyboardHook.HelpPressed += OnHelpPressed;
             _keyboardHook.Start();
 
             // Setup system tray icon
@@ -251,6 +254,57 @@ private void OnClearCanvasPressed(object? sender, EventArgs e)
         }
     }
 
+    private void OnPenToolPressed(object? sender, EventArgs e)
+    {
+        try
+        {
+            // Only switch to pen tool if drawing mode is active
+            if (_drawingManager?.IsDrawingMode == true)
+            {
+                _logger?.LogInformation("P pressed - selecting pen tool");
+                _drawingManager?.SetPenTool();
+            }
+        }
+        catch (Exception ex)
+        {
+            _exceptionHandler?.HandleException(ex, "Pen tool handler");
+        }
+    }
+
+    private void OnLineToolPressed(object? sender, EventArgs e)
+    {
+        try
+        {
+            // Only switch to line tool if drawing mode is active
+            if (_drawingManager?.IsDrawingMode == true)
+            {
+                _logger?.LogInformation("L pressed - selecting line tool");
+                _drawingManager?.SetLineTool();
+            }
+        }
+        catch (Exception ex)
+        {
+            _exceptionHandler?.HandleException(ex, "Line tool handler");
+        }
+    }
+
+    private void OnHelpPressed(object? sender, EventArgs e)
+    {
+        try
+        {
+            // Show help overlay if drawing mode is active
+            if (_drawingManager?.IsDrawingMode == true)
+            {
+                _logger?.LogInformation("F1 pressed - showing help");
+                _drawingManager?.ShowHelp();
+            }
+        }
+        catch (Exception ex)
+        {
+            _exceptionHandler?.HandleException(ex, "Help pressed handler");
+        }
+    }
+
     protected override void OnExit(ExitEventArgs e)
     {
         _logger?.LogInformation("Application exiting");

Src/GhostDraw/Core/AppSettings.cs

@@ -31,6 +31,12 @@ public class AppSettings
     [JsonPropertyName("maxBrushThickness")]
     public double MaxBrushThickness { get; set; } = 20.0;
 
+    /// <summary>
+    /// The currently active drawing tool
+    /// </summary>
+    [JsonPropertyName("activeTool")]
+    public DrawTool ActiveTool { get; set; } = DrawTool.Pen;
+
     /// <summary>
     /// Virtual key codes for the hotkey combination
     /// </summary>
@@ -86,6 +92,7 @@ public AppSettings Clone()
             BrushThickness = BrushThickness,
             MinBrushThickness = MinBrushThickness,
             MaxBrushThickness = MaxBrushThickness,
+            ActiveTool = ActiveTool,
             HotkeyVirtualKeys = new List<int>(HotkeyVirtualKeys),
             LockDrawingMode = LockDrawingMode,
             LogLevel = LogLevel,

Src/GhostDraw/Core/DrawTool.cs

@@ -0,0 +1,20 @@
+using System.Text.Json.Serialization;
+
+namespace GhostDraw.Core;
+
+/// <summary>
+/// Available drawing tools
+/// </summary>
+[JsonConverter(typeof(JsonStringEnumConverter))]
+public enum DrawTool
+{
+    /// <summary>
+    /// Freehand drawing tool (default)
+    /// </summary>
+    Pen,
+    
+    /// <summary>
+    /// Straight line tool - click two points to draw a line
+    /// </summary>
+    Line
+}

Src/GhostDraw/Core/GlobalKeyboardHook.cs

@@ -13,6 +13,9 @@ public class GlobalKeyboardHook : IDisposable
     // Only keep VK_ESCAPE constant (emergency exit)
     private const int VK_ESCAPE = 0x1B;    // 27
     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_F1 = 0x70;        // 112 - 'F1' key for help
 
     private readonly ILogger<GlobalKeyboardHook> _logger;
     private readonly LowLevelKeyboardProc _proc;
@@ -25,6 +28,9 @@ public class GlobalKeyboardHook : IDisposable
     public event EventHandler? HotkeyReleased;
     public event EventHandler? EscapePressed;
     public event EventHandler? ClearCanvasPressed;
+    public event EventHandler? PenToolPressed;
+    public event EventHandler? LineToolPressed;
+    public event EventHandler? HelpPressed;
 
     // NEW: Raw key events for recorder
     public event EventHandler<KeyEventArgs>? KeyPressed;
@@ -190,6 +196,27 @@ private nint HookCallback(int nCode, nint wParam, nint lParam)
                     ClearCanvasPressed?.Invoke(this, EventArgs.Empty);
                 }
 
+                // Check for L key press (line tool)
+                if (vkCode == VK_L && isKeyDown)
+                {
+                    _logger.LogDebug("L key pressed - line tool request");
+                    LineToolPressed?.Invoke(this, EventArgs.Empty);
+                }
+
+                // Check for P key press (pen tool)
+                if (vkCode == VK_P && isKeyDown)
+                {
+                    _logger.LogDebug("P key pressed - pen tool request");
+                    PenToolPressed?.Invoke(this, EventArgs.Empty);
+                }
+
+                // Check for F1 key press (help)
+                if (vkCode == VK_F1 && isKeyDown)
+                {
+                    _logger.LogDebug("F1 key pressed - help request");
+                    HelpPressed?.Invoke(this, EventArgs.Empty);
+                }
+
                 // Track hotkey state
                 if (_hotkeyVKs.Contains(vkCode))
                 {

Src/GhostDraw/Core/ServiceConfiguration.cs

@@ -51,6 +51,9 @@ public static ServiceProvider ConfigureServices()
             builder.AddSerilog(dispose: true);
         });
 
+        // Register settings store (file-based for production)
+        services.AddSingleton<ISettingsStore, FileSettingsStore>();
+
         // Register application services (order matters for dependencies)
         services.AddSingleton<AppSettingsService>();
         services.AddSingleton<CursorHelper>();

Src/GhostDraw/Helpers/CursorHelper.cs

@@ -147,6 +147,125 @@ public WpfCursor CreateColoredPencilCursor(string tipColorHex)
         }
     }
 
+    /// <summary>
+    /// Creates a crosshair cursor with color indicator for the Line tool
+    /// </summary>
+    /// <param name="colorHex">Hex color for the line (e.g., "#FF0000")</param>
+    /// <returns>Custom cursor</returns>
+    public WpfCursor CreateLineCursor(string colorHex)
+    {
+        lock (_cursorLock)
+        {
+            if (_disposed)
+            {
+                _logger.LogWarning("CreateLineCursor called on disposed CursorHelper");
+                return WpfCursors.Cross;
+            }
+
+            try
+            {
+                _logger.LogDebug("Creating line cursor with color {Color}", colorHex);
+
+                // 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);
+
+                    // Parse the line color
+                    Color lineColor = ColorTranslator.FromHtml(colorHex);
+
+                    // Draw two circles with a line connecting them
+                    // Left circle is at the hotspot (where the mouse clicks)
+                    int circleRadius = 4;
+                    int circleSpacing = 20; // Increased spacing for better visibility
+                    
+                    // Position left circle at the hotspot (6 pixels from left edge for visual balance)
+                    Point leftCircleCenter = new Point(6, size / 2);
+                    Point rightCircleCenter = new Point(6 + circleSpacing, size / 2);
+
+                    // Draw connecting line with the active color
+                    using (Pen linePen = new Pen(lineColor, 2))
+                    {
+                        g.DrawLine(linePen, leftCircleCenter, rightCircleCenter);
+                    }
+
+                    // Draw left circle (outline) - this is where the line starts
+                    using (Pen circlePen = new Pen(Color.White, 2))
+                    {
+                        g.DrawEllipse(circlePen, 
+                            leftCircleCenter.X - circleRadius, 
+                            leftCircleCenter.Y - circleRadius, 
+                            circleRadius * 2, 
+                            circleRadius * 2);
+                    }
+                    using (Pen circleOutline = new Pen(Color.Black, 1))
+                    {
+                        g.DrawEllipse(circleOutline, 
+                            leftCircleCenter.X - circleRadius - 1, 
+                            leftCircleCenter.Y - circleRadius - 1, 
+                            circleRadius * 2 + 2, 
+                            circleRadius * 2 + 2);
+                    }
+
+                    // Draw right circle (outline)
+                    using (Pen circlePen = new Pen(Color.White, 2))
+                    {
+                        g.DrawEllipse(circlePen, 
+                            rightCircleCenter.X - circleRadius, 
+                            rightCircleCenter.Y - circleRadius, 
+                            circleRadius * 2, 
+                            circleRadius * 2);
+                    }
+                    using (Pen circleOutline = new Pen(Color.Black, 1))
+                    {
+                        g.DrawEllipse(circleOutline, 
+                            rightCircleCenter.X - circleRadius - 1, 
+                            rightCircleCenter.Y - circleRadius - 1, 
+                            circleRadius * 2 + 2, 
+                            circleRadius * 2 + 2);
+                    }
+
+                    // Convert bitmap to cursor with hotspot at the left circle center
+                    nint hCursor = CreateCursorFromBitmap(bitmap, leftCircleCenter.X, leftCircleCenter.Y);
+
+                    if (hCursor != nint.Zero)
+                    {
+                        _currentCursorHandle = hCursor;
+                        _logger.LogDebug("Successfully created line cursor (handle: {Handle})", hCursor);
+
+                        return System.Windows.Interop.CursorInteropHelper.Create(new SafeCursorHandle(hCursor));
+                    }
+                }
+
+                _logger.LogWarning("Failed to create line cursor, returning default");
+                return WpfCursors.Cross;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error creating line cursor, using default");
+                return WpfCursors.Cross;
+            }
+        }
+    }
+
     private nint CreateCursorFromBitmap(Bitmap bitmap, int hotspotX, int hotspotY)
     {
         nint hIcon = nint.Zero;