Merge pull request #20 from RuntimeRascal/copilot/add-screenshot-hotkey

Add screenshot capture hotkeys (Ctrl+S full screen)

Author: RuntimeRascal

CHANGELOG.md

@@ -5,6 +5,23 @@ 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.7
+
+### 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)
+- **Screenshot Settings Panel** - New UI section in Settings window
+  - Toggle clipboard copy, folder opening, and sound effects
+  - Configurable save location
+- **Key Legend Documentation** - Comprehensive keyboard shortcut reference (`docs/KEY-LEGEND.md`)
+
+### 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
+- Thread safety improvements with volatile field for update nesting level
+
 ## v1.0.6
 
 ### Added
@@ -16,10 +33,14 @@ 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
+- 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
 
 ## v1.0.5
 

Installer/GhostDraw.Installer.wixproj

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

Src/GhostDraw/App.xaml.cs

@@ -78,6 +78,7 @@ protected override void OnStartup(StartupEventArgs e)
             _keyboardHook.LineToolPressed += OnLineToolPressed;
             _keyboardHook.EraserToolPressed += OnEraserToolPressed;
             _keyboardHook.HelpPressed += OnHelpPressed;
+            _keyboardHook.ScreenshotFullPressed += OnScreenshotFullPressed;
             _keyboardHook.Start();
 
             // Setup system tray icon
@@ -323,6 +324,34 @@ private void OnHelpPressed(object? sender, EventArgs e)
         }
     }
 
+    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 (calling DrawingManager.CaptureFullScreenshot)");
+                _drawingManager?.CaptureFullScreenshot();
+                _logger?.LogInformation("DrawingManager.CaptureFullScreenshot call completed");
+            }
+            else
+            {
+                _logger?.LogWarning("Screenshot ignored - drawing mode is NOT active");
+            }
+            _logger?.LogInformation("====== OnScreenshotFullPressed COMPLETED ======");
+        }
+        catch (Exception ex)
+        {
+            _logger?.LogError(ex, "Exception in OnScreenshotFullPressed");
+            _exceptionHandler?.HandleException(ex, "Screenshot full pressed handler");
+        }
+    }
+
     protected override void OnExit(ExitEventArgs e)
     {
         _logger?.LogInformation("Application exiting");

Src/GhostDraw/Core/AppSettings.cs

@@ -81,6 +81,32 @@ public class AppSettings
         "#800080"  // Purple
     };
 
+    /// <summary>
+    /// Directory path where screenshots will be saved
+    /// </summary>
+    [JsonPropertyName("screenshotSavePath")]
+    public string ScreenshotSavePath { get; set; } = System.IO.Path.Combine(
+        Environment.GetFolderPath(Environment.SpecialFolder.MyPictures), 
+        "GhostDraw");
+
+    /// <summary>
+    /// If true, copies screenshot to clipboard after capture
+    /// </summary>
+    [JsonPropertyName("copyScreenshotToClipboard")]
+    public bool CopyScreenshotToClipboard { get; set; } = true;
+
+    /// <summary>
+    /// If true, plays a shutter sound when screenshot is captured
+    /// </summary>
+    [JsonPropertyName("playShutterSound")]
+    public bool PlayShutterSound { get; set; } = false;
+
+    /// <summary>
+    /// If true, opens the folder after screenshot is saved
+    /// </summary>
+    [JsonPropertyName("openFolderAfterScreenshot")]
+    public bool OpenFolderAfterScreenshot { get; set; } = false;
+
     /// <summary>
     /// Creates a deep copy of the settings
     /// </summary>
@@ -96,7 +122,11 @@ public AppSettings Clone()
             HotkeyVirtualKeys = new List<int>(HotkeyVirtualKeys),
             LockDrawingMode = LockDrawingMode,
             LogLevel = LogLevel,
-            ColorPalette = new List<string>(ColorPalette)
+            ColorPalette = new List<string>(ColorPalette),
+            ScreenshotSavePath = ScreenshotSavePath,
+            CopyScreenshotToClipboard = CopyScreenshotToClipboard,
+            PlayShutterSound = PlayShutterSound,
+            OpenFolderAfterScreenshot = OpenFolderAfterScreenshot
         };
     }
 }

Src/GhostDraw/Core/GlobalKeyboardHook.cs

@@ -1,4 +1,4 @@
-using System.Diagnostics;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 using Microsoft.Extensions.Logging;
 
@@ -17,6 +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 (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;
@@ -33,6 +36,7 @@ public class GlobalKeyboardHook : IDisposable
     public event EventHandler? LineToolPressed;
     public event EventHandler? EraserToolPressed;
     public event EventHandler? HelpPressed;
+    public event EventHandler? ScreenshotFullPressed;
 
     // NEW: Raw key events for recorder
     public event EventHandler<KeyEventArgs>? KeyPressed;
@@ -42,6 +46,10 @@ public class GlobalKeyboardHook : IDisposable
     private List<int> _hotkeyVKs = new() { 0xA2, 0xA4, 0x44 };  // Default: Ctrl+Alt+D
     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)
     {
@@ -53,7 +61,7 @@ public GlobalKeyboardHook(ILogger<GlobalKeyboardHook> logger)
         foreach (var vk in _hotkeyVKs)
             _keyStates[vk] = false;
     }
-
+    
     /// <summary>
     /// Configures the hotkey combination
     /// </summary>
@@ -171,6 +179,8 @@ private nint SetHook(LowLevelKeyboardProc proc)
 
     private nint HookCallback(int nCode, nint wParam, nint lParam)
     {
+        bool shouldSuppressKey = false;
+        
         try
         {
             if (nCode >= 0)
@@ -184,10 +194,19 @@ private nint HookCallback(int nCode, nint wParam, nint lParam)
                 else
                     KeyReleased?.Invoke(this, new KeyEventArgs(vkCode));
 
+                // 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);
                 }
 
@@ -226,6 +245,32 @@ private nint HookCallback(int nCode, nint wParam, nint lParam)
                     HelpPressed?.Invoke(this, EventArgs.Empty);
                 }
 
+                // Check for Ctrl+S key press (full screenshot only - no snipping tool)
+                if (vkCode == VK_S && isKeyDown && _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)
+                    {
+                        shouldSuppressKey = true;
+                        _logger.LogInformation("KEY WILL BE SUPPRESSED - Drawing mode is active");
+                    }
+                    else
+                    {
+                        _logger.LogInformation("KEY WILL NOT BE SUPPRESSED - Drawing mode is inactive");
+                    }
+                    
+                    _logger.LogInformation("====== END CTRL+S HANDLING ======");
+                }
+
                 // Track hotkey state
                 if (_hotkeyVKs.Contains(vkCode))
                 {
@@ -239,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);
                     }
 
@@ -258,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);
     }
 
@@ -280,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);
 

Src/GhostDraw/Core/ServiceConfiguration.cs

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

Src/GhostDraw/GhostDraw.csproj

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