Add Circle tool with bounding box approach and Shift for perfect circles

Co-authored-by: RuntimeRascal <2422222+RuntimeRascal@users.noreply.github.com>

Author: Copilot

Src/GhostDraw/App.xaml.cs

@@ -78,6 +78,7 @@ protected override void OnStartup(StartupEventArgs e)
             _keyboardHook.LineToolPressed += OnLineToolPressed;
             _keyboardHook.EraserToolPressed += OnEraserToolPressed;
             _keyboardHook.RectangleToolPressed += OnRectangleToolPressed;
+            _keyboardHook.CircleToolPressed += OnCircleToolPressed;
             _keyboardHook.HelpPressed += OnHelpPressed;
             _keyboardHook.ScreenshotFullPressed += OnScreenshotFullPressed;
             _keyboardHook.Start();
@@ -325,6 +326,23 @@ private void OnRectangleToolPressed(object? sender, EventArgs e)
         }
     }
 
+    private void OnCircleToolPressed(object? sender, EventArgs e)
+    {
+        try
+        {
+            // Only switch to circle tool if drawing mode is active
+            if (_drawingManager?.IsDrawingMode == true)
+            {
+                _logger?.LogInformation("C pressed - selecting circle tool");
+                _drawingManager?.SetCircleTool();
+            }
+        }
+        catch (Exception ex)
+        {
+            _exceptionHandler?.HandleException(ex, "Circle tool handler");
+        }
+    }
+
     private void OnHelpPressed(object? sender, EventArgs e)
     {
         try

Src/GhostDraw/Core/DrawTool.cs

@@ -26,5 +26,10 @@ public enum DrawTool
     /// <summary>
     /// Rectangle tool - click two points to draw a rectangle
     /// </summary>
-    Rectangle
+    Rectangle,
+    
+    /// <summary>
+    /// Circle tool - click two points to draw a circle/ellipse
+    /// </summary>
+    Circle
 }

Src/GhostDraw/Core/GlobalKeyboardHook.cs

@@ -17,6 +17,7 @@ public class GlobalKeyboardHook : IDisposable
     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_U = 0x55;         // 85 - 'U' key for rectangle tool
+    private const int VK_C = 0x43;         // 67 - 'C' key for circle 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_LCONTROL = 0xA2;  // 162 - Left Control key
@@ -37,6 +38,7 @@ public class GlobalKeyboardHook : IDisposable
     public event EventHandler? LineToolPressed;
     public event EventHandler? EraserToolPressed;
     public event EventHandler? RectangleToolPressed;
+    public event EventHandler? CircleToolPressed;
     public event EventHandler? HelpPressed;
     public event EventHandler? ScreenshotFullPressed;
 
@@ -247,6 +249,13 @@ private nint HookCallback(int nCode, nint wParam, nint lParam)
                     RectangleToolPressed?.Invoke(this, EventArgs.Empty);
                 }
 
+                // Check for C key press (circle tool)
+                if (vkCode == VK_C && isKeyDown)
+                {
+                    _logger.LogDebug("C key pressed - circle tool request");
+                    CircleToolPressed?.Invoke(this, EventArgs.Empty);
+                }
+
                 // Check for F1 key press (help)
                 if (vkCode == VK_F1 && isKeyDown)
                 {

Src/GhostDraw/Core/ServiceConfiguration.cs

@@ -64,6 +64,7 @@ public static ServiceProvider ConfigureServices()
         services.AddSingleton<GhostDraw.Tools.LineTool>();
         services.AddSingleton<GhostDraw.Tools.EraserTool>();
         services.AddSingleton<GhostDraw.Tools.RectangleTool>();
+        services.AddSingleton<GhostDraw.Tools.CircleTool>();
 
         services.AddSingleton<OverlayWindow>();
         services.AddSingleton<GlobalKeyboardHook>();

Src/GhostDraw/Helpers/CursorHelper.cs

@@ -480,6 +480,108 @@ public WpfCursor CreateLineCursor(string colorHex)
         }
     }
 
+    /// <summary>
+    /// Creates a cursor for the Circle tool with color indicator
+    /// </summary>
+    /// <param name="colorHex">Hex color for the circle (e.g., "#FF0000")</param>
+    /// <returns>Custom cursor</returns>
+    public WpfCursor CreateCircleCursor(string colorHex)
+    {
+        lock (_cursorLock)
+        {
+            if (_disposed)
+            {
+                _logger.LogWarning("CreateCircleCursor called on disposed CursorHelper");
+                return WpfCursors.Cross;
+            }
+
+            try
+            {
+                _logger.LogDebug("Creating circle 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 circle color
+                    Color circleColor = ColorTranslator.FromHtml(colorHex);
+
+                    // Draw a small circle preview
+                    int circleRadius = 6;
+                    int circleLeft = 6;
+                    int circleTop = (size - circleRadius * 2) / 2;
+
+                    // Draw circle outline with the active color
+                    using (Pen circlePen = new Pen(circleColor, 2))
+                    {
+                        g.DrawEllipse(circlePen, circleLeft, circleTop, circleRadius * 2, circleRadius * 2);
+                    }
+
+                    // Draw corner markers (small filled squares at key points - top-left, top-right, bottom-left, bottom-right)
+                    int cornerSize = 3;
+                    using (SolidBrush cornerBrush = new SolidBrush(Color.White))
+                    {
+                        // Top-left (this is the hotspot - represents bounding box corner)
+                        g.FillRectangle(cornerBrush, circleLeft - 1, circleTop - 1, cornerSize, cornerSize);
+                        // Top-right
+                        g.FillRectangle(cornerBrush, circleLeft + circleRadius * 2 - 1, circleTop - 1, cornerSize, cornerSize);
+                        // Bottom-left
+                        g.FillRectangle(cornerBrush, circleLeft - 1, circleTop + circleRadius * 2 - 1, cornerSize, cornerSize);
+                        // Bottom-right
+                        g.FillRectangle(cornerBrush, circleLeft + circleRadius * 2 - 1, circleTop + circleRadius * 2 - 1, cornerSize, cornerSize);
+                    }
+
+                    // Draw black outlines for corner markers
+                    using (Pen cornerOutline = new Pen(Color.Black, 1))
+                    {
+                        g.DrawRectangle(cornerOutline, circleLeft - 1, circleTop - 1, cornerSize, cornerSize);
+                        g.DrawRectangle(cornerOutline, circleLeft + circleRadius * 2 - 1, circleTop - 1, cornerSize, cornerSize);
+                        g.DrawRectangle(cornerOutline, circleLeft - 1, circleTop + circleRadius * 2 - 1, cornerSize, cornerSize);
+                        g.DrawRectangle(cornerOutline, circleLeft + circleRadius * 2 - 1, circleTop + circleRadius * 2 - 1, cornerSize, cornerSize);
+                    }
+
+                    // Convert bitmap to cursor with hotspot at top-left corner marker
+                    nint hCursor = CreateCursorFromBitmap(bitmap, circleLeft, circleTop);
+
+                    if (hCursor != nint.Zero)
+                    {
+                        _currentCursorHandle = hCursor;
+                        _logger.LogDebug("Successfully created circle cursor (handle: {Handle})", hCursor);
+
+                        return System.Windows.Interop.CursorInteropHelper.Create(new SafeCursorHandle(hCursor));
+                    }
+                }
+
+                _logger.LogWarning("Failed to create circle cursor, returning default");
+                return WpfCursors.Cross;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error creating circle cursor, using default");
+                return WpfCursors.Cross;
+            }
+        }
+    }
+
     private nint CreateCursorFromBitmap(Bitmap bitmap, int hotspotX, int hotspotY)
     {
         nint hIcon = nint.Zero;

Src/GhostDraw/Managers/DrawingManager.cs

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