chore: screen capture tool and key legend

Author: RuntimeRascal

CHANGELOG.md

@@ -5,9 +5,14 @@ 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
+- **Screenshot Capture** - Capture your drawings as images
+  - Press `Ctrl+S` to capture full screen with drawings (saved to Pictures\GhostDraw)
+  - Key suppression prevents Windows from intercepting Ctrl+S during drawing mode
+  - Optional: Copy to clipboard, open folder, play shutter sound (configurable in settings)
 - **Eraser Tool** - Remove drawing objects underneath the cursor
   - Press `E` to activate Eraser tool
   - Click and drag to erase drawings interactively
@@ -16,10 +21,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Works with both polylines (pen strokes) and lines (straight line tool)
   - Custom eraser cursor with visual feedback
 - **Improved Code Quality**
+  - Added explicit type aliases to resolve WPF/WinForms namespace conflicts
+  - Fixed `Point`, `Brush`, `Color`, `ColorConverter`, and `Brushes` type ambiguities
   - Enhanced tool interface consistency
 
 ### Fixed
+- Screenshot hotkey (`Ctrl+S`) now correctly detects Control key by tracking both left (VK_LCONTROL) and right (VK_RCONTROL) control keys instead of generic VK_CONTROL
+- Ambiguous reference errors caused by both WPF (`System.Windows`) and WinForms (`System.Drawing`) being enabled
 - LineTool's `OnDeactivated` method now properly resets state without calling non-existent method
+- Build errors related to namespace conflicts in drawing tool implementations
+
+### Changed
+- Snipping tool (`S` key) now properly exits drawing mode to allow user interaction
+- User must manually reactivate drawing mode after using snipping tool (press hotkey)
 
 ## v1.0.5
 

Src/GhostDraw/App.xaml.cs

@@ -79,7 +79,6 @@ protected override void OnStartup(StartupEventArgs e)
             _keyboardHook.EraserToolPressed += OnEraserToolPressed;
             _keyboardHook.HelpPressed += OnHelpPressed;
             _keyboardHook.ScreenshotFullPressed += OnScreenshotFullPressed;
-            _keyboardHook.ScreenshotSnipPressed += OnScreenshotSnipPressed;
             _keyboardHook.Start();
 
             // Setup system tray icon
@@ -329,33 +328,27 @@ private void OnScreenshotFullPressed(object? sender, EventArgs e)
     {
         try
         {
+            _logger?.LogInformation("====== OnScreenshotFullPressed CALLED ======");
+            _logger?.LogInformation("DrawingManager null: {IsNull}", _drawingManager == null);
+            _logger?.LogInformation("DrawingManager.IsDrawingMode: {IsDrawingMode}", _drawingManager?.IsDrawingMode);
+            
             // Capture full screenshot if drawing mode is active
             if (_drawingManager?.IsDrawingMode == true)
             {
-                _logger?.LogInformation("Ctrl+S pressed - capturing full screenshot");
+                _logger?.LogInformation("Ctrl+S pressed - capturing full screenshot (calling DrawingManager.CaptureFullScreenshot)");
                 _drawingManager?.CaptureFullScreenshot();
+                _logger?.LogInformation("DrawingManager.CaptureFullScreenshot call completed");
             }
-        }
-        catch (Exception ex)
-        {
-            _exceptionHandler?.HandleException(ex, "Screenshot full pressed handler");
-        }
-    }
-
-    private void OnScreenshotSnipPressed(object? sender, EventArgs e)
-    {
-        try
-        {
-            // Open snipping tool if drawing mode is active
-            if (_drawingManager?.IsDrawingMode == true)
+            else
             {
-                _logger?.LogInformation("S pressed - opening snipping tool");
-                _drawingManager?.OpenSnippingTool();
+                _logger?.LogWarning("Screenshot ignored - drawing mode is NOT active");
             }
+            _logger?.LogInformation("====== OnScreenshotFullPressed COMPLETED ======");
         }
         catch (Exception ex)
         {
-            _exceptionHandler?.HandleException(ex, "Screenshot snip pressed handler");
+            _logger?.LogError(ex, "Exception in OnScreenshotFullPressed");
+            _exceptionHandler?.HandleException(ex, "Screenshot full pressed handler");
         }
     }
 

Src/GhostDraw/Core/GlobalKeyboardHook.cs

@@ -1,4 +1,4 @@
-using System.Diagnostics;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 using Microsoft.Extensions.Logging;
 
@@ -17,8 +17,9 @@ 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_F1 = 0x70;        // 112 - 'F1' key for help
-    private const int VK_S = 0x53;         // 83 - 'S' key for screenshot (snipping tool)
-    private const int VK_CONTROL = 0x11;   // 17 - Control key
+    private const int VK_S = 0x53;         // 83 - 'S' key for screenshot (Ctrl+S only)
+    private const int VK_LCONTROL = 0xA2;  // 162 - Left Control key
+    private const int VK_RCONTROL = 0xA3;  // 163 - Right Control key
 
     private readonly ILogger<GlobalKeyboardHook> _logger;
     private readonly LowLevelKeyboardProc _proc;
@@ -36,7 +37,6 @@ public class GlobalKeyboardHook : IDisposable
     public event EventHandler? EraserToolPressed;
     public event EventHandler? HelpPressed;
     public event EventHandler? ScreenshotFullPressed;
-    public event EventHandler? ScreenshotSnipPressed;
 
     // NEW: Raw key events for recorder
     public event EventHandler<KeyEventArgs>? KeyPressed;
@@ -47,6 +47,9 @@ public class GlobalKeyboardHook : IDisposable
     private Dictionary<int, bool> _keyStates = new();
     private bool _wasHotkeyActive = false;
     private volatile bool _isControlPressed = false;
+    
+    // Drawing mode state - used to determine if we should suppress keys
+    private volatile bool _isDrawingModeActive = false;
 
     public GlobalKeyboardHook(ILogger<GlobalKeyboardHook> logger)
     {
@@ -58,7 +61,7 @@ public GlobalKeyboardHook(ILogger<GlobalKeyboardHook> logger)
         foreach (var vk in _hotkeyVKs)
             _keyStates[vk] = false;
     }
-
+    
     /// <summary>
     /// Configures the hotkey combination
     /// </summary>
@@ -176,6 +179,8 @@ private nint SetHook(LowLevelKeyboardProc proc)
 
     private nint HookCallback(int nCode, nint wParam, nint lParam)
     {
+        bool shouldSuppressKey = false;
+        
         try
         {
             if (nCode >= 0)
@@ -189,16 +194,19 @@ private nint HookCallback(int nCode, nint wParam, nint lParam)
                 else
                     KeyReleased?.Invoke(this, new KeyEventArgs(vkCode));
 
-                // Track Control key state
-                if (vkCode == VK_CONTROL)
+                // Track Control key state (both left and right control keys)
+                if (vkCode == VK_LCONTROL || vkCode == VK_RCONTROL)
                 {
                     _isControlPressed = isKeyDown;
+                    _logger.LogDebug("Control key ({Type}) {State}", 
+                        vkCode == VK_LCONTROL ? "Left" : "Right", 
+                        isKeyDown ? "PRESSED" : "RELEASED");
                 }
 
                 // Check for ESC key press (emergency exit)
                 if (vkCode == VK_ESCAPE && isKeyDown)
                 {
-                    _logger.LogInformation("?? ESC pressed - emergency exit");
+                    _logger.LogInformation("🔴 ESC pressed - emergency exit");
                     EscapePressed?.Invoke(this, EventArgs.Empty);
                 }
 
@@ -237,20 +245,30 @@ private nint HookCallback(int nCode, nint wParam, nint lParam)
                     HelpPressed?.Invoke(this, EventArgs.Empty);
                 }
 
-                // Check for S key press (screenshot)
-                if (vkCode == VK_S && isKeyDown)
+                // Check for Ctrl+S key press (full screenshot only - no snipping tool)
+                if (vkCode == VK_S && isKeyDown && _isControlPressed)
                 {
-                    // Use tracked Control key state to determine action
-                    if (_isControlPressed)
+                    _logger.LogInformation("====== CTRL+S DETECTED ======");
+                    _logger.LogInformation("Control key state: {IsControlPressed}", _isControlPressed);
+                    _logger.LogInformation("Drawing mode active: {IsDrawingModeActive}", _isDrawingModeActive);
+                    
+                    _logger.LogInformation("Ctrl+S pressed - firing ScreenshotFullPressed event");
+                    ScreenshotFullPressed?.Invoke(this, EventArgs.Empty);
+                    _logger.LogInformation("ScreenshotFullPressed event fired, subscribers: {Count}", 
+                        ScreenshotFullPressed?.GetInvocationList().Length ?? 0);
+                    
+                    // Suppress Ctrl+S when drawing mode is active to prevent Windows Snipping Tool
+                    if (_isDrawingModeActive)
                     {
-                        _logger.LogDebug("Ctrl+S pressed - full screenshot request");
-                        ScreenshotFullPressed?.Invoke(this, EventArgs.Empty);
+                        shouldSuppressKey = true;
+                        _logger.LogInformation("KEY WILL BE SUPPRESSED - Drawing mode is active");
                     }
                     else
                     {
-                        _logger.LogDebug("S key pressed - snipping tool request");
-                        ScreenshotSnipPressed?.Invoke(this, EventArgs.Empty);
+                        _logger.LogInformation("KEY WILL NOT BE SUPPRESSED - Drawing mode is inactive");
                     }
+                    
+                    _logger.LogInformation("====== END CTRL+S HANDLING ======");
                 }
 
                 // Track hotkey state
@@ -266,12 +284,12 @@ private nint HookCallback(int nCode, nint wParam, nint lParam)
                     // Fire events on state changes
                     if (allPressed && !_wasHotkeyActive)
                     {
-                        _logger.LogInformation("?? HOTKEY PRESSED");
+                        _logger.LogInformation("🟢 HOTKEY PRESSED");
                         HotkeyPressed?.Invoke(this, EventArgs.Empty);
                     }
                     else if (!allPressed && _wasHotkeyActive)
                     {
-                        _logger.LogInformation("?? HOTKEY RELEASED");
+                        _logger.LogInformation("🟢 HOTKEY RELEASED");
                         HotkeyReleased?.Invoke(this, EventArgs.Empty);
                     }
 
@@ -285,7 +303,15 @@ private nint HookCallback(int nCode, nint wParam, nint lParam)
             _logger.LogError(ex, "Exception in keyboard hook callback");
         }
 
-        // MUST ALWAYS call CallNextHookEx to allow other applications to process the hook
+        // If we want to suppress the key, return 1 to block it from reaching other applications
+        // Otherwise, call CallNextHookEx to allow other applications to process the hook
+        if (shouldSuppressKey)
+        {
+            _logger.LogTrace("Key suppressed - not calling CallNextHookEx");
+            return (nint)1;
+        }
+        
+        // MUST call CallNextHookEx for non-suppressed keys to allow other applications to process them
         return CallNextHookEx(_hookID, nCode, wParam, lParam);
     }
 
@@ -307,6 +333,27 @@ public void Dispose()
         }
     }
 
+    /// <summary>
+    /// Sets the drawing mode state. When active, certain keys (like Ctrl+S) will be suppressed
+    /// to prevent Windows from intercepting them.
+    /// </summary>
+    public void SetDrawingModeActive(bool isActive)
+    {
+        var previousState = _isDrawingModeActive;
+        _isDrawingModeActive = isActive;
+        
+        if (previousState != isActive)
+        {
+            _logger.LogInformation("====== DRAWING MODE STATE CHANGED ======");
+            _logger.LogInformation("Previous state: {PreviousState}, New state: {NewState}", previousState, isActive);
+            _logger.LogInformation("Timestamp: {Timestamp}", DateTime.Now.ToString("HH:mm:ss.fff"));
+        }
+        else
+        {
+            _logger.LogDebug("Drawing mode state set to: {IsActive} (no change)", isActive);
+        }
+    }
+
     // P/Invoke declarations
     private delegate nint LowLevelKeyboardProc(int nCode, nint wParam, nint lParam);