Comment capturer la touche Impr écran?

Question

J'ai mon programme que j'ai besoin de capturer lorsque la touche Impr écran est enfoncée mais elle ne fonctionne pas (mais cela fonctionne avec d'autres touches).

Je suppose que cela a quelque chose à voir avec Windows détournant mon autorité et comme je suis encore nouveau à ce sujet, j'aimerais savoir comment je peux contourner ce problème.

Voici mon code actuel:

namespace Boom_Screenshot_ 
{ 
    /// <summary> 
    /// Interaction logic for Window1.xaml 
    /// </summary> 
    public partial class Window1 : Window 
    { 
     //SETTINGS 
     Key TRIGGER_KEY = Key.PrintScreen; 

     public Window1() 
     { 
      InitializeComponent(); 
     } 

     private void Window_KeyDown(object sender, KeyEventArgs e) 
     { 
      if (e.Key == TRIGGER_KEY) 
      { 
       MessageBox.Show("'PrintScreen' was pressed."); 
      } 
     } 
    } 
} 

Answer 1

J'ai une réponse pour vous que j'ai trouvé here (je ne parle pas chinois, alors ne me demandez pas ce qu'il dit :). Vous devez définir un crochet. Il fournit une classe d'emballage. Je répète du code ici sans les caractères chinois. RegisterHotKey.cs ...

using System; 
using System.Runtime.InteropServices; 
using System.Windows.Forms; 

namespace TestKeydown 
{ 
    public class RegisterHotKeyClass 
    { 
     private IntPtr m_WindowHandle = IntPtr.Zero; 
     private MODKEY m_ModKey = MODKEY.MOD_CONTROL; 
     private Keys m_Keys = Keys.A; 
     private int m_WParam = 10000; 
     private bool Star = false; 
     private HotKeyWndProc m_HotKeyWnd = new HotKeyWndProc(); 

     public IntPtr WindowHandle 
     { 
      get { return m_WindowHandle; } 
      set { if (Star)return; m_WindowHandle = value; } 
     } 
     public MODKEY ModKey 
     { 
      get { return m_ModKey; } 
      set { if (Star)return; m_ModKey = value; } 
     } 
     public Keys Keys 
     { 
      get { return m_Keys; } 
      set { if (Star)return; m_Keys = value; } 
     } 
     public int WParam 
     { 
      get { return m_WParam; } 
      set { if (Star)return; m_WParam = value; } 
     } 

     public void StarHotKey() 
     { 
      if (m_WindowHandle != IntPtr.Zero) 
      { 
       if (!RegisterHotKey(m_WindowHandle, m_WParam, m_ModKey, m_Keys)) 
       { 
        throw new Exception(""); 
       } 
       try 
       { 
        m_HotKeyWnd.m_HotKeyPass = new HotKeyPass(KeyPass); 
        m_HotKeyWnd.m_WParam = m_WParam; 
        m_HotKeyWnd.AssignHandle(m_WindowHandle); 
        Star = true; 
       } 
       catch 
       { 
        StopHotKey(); 
       } 
      } 
     } 
     private void KeyPass() 
     { 
      if (HotKey != null) HotKey(); 
     } 
     public void StopHotKey() 
     { 
      if (Star) 
      { 
       if (!UnregisterHotKey(m_WindowHandle, m_WParam)) 
       { 
        throw new Exception(""); 
       } 
       Star = false; 
       m_HotKeyWnd.ReleaseHandle(); 
      } 
     } 


     public delegate void HotKeyPass(); 
     public event HotKeyPass HotKey; 


     private class HotKeyWndProc : NativeWindow 
     { 
      public int m_WParam = 10000; 
      public HotKeyPass m_HotKeyPass; 
      protected override void WndProc(ref Message m) 
      { 
       if (m.Msg == 0x0312 && m.WParam.ToInt32() == m_WParam) 
       { 
        if (m_HotKeyPass != null) m_HotKeyPass.Invoke(); 
       } 

       base.WndProc(ref m); 
      } 
     } 

     public enum MODKEY 
     { 
      MOD_ALT = 0x0001, 
      MOD_CONTROL = 0x0002, 
      MOD_SHIFT = 0x0004, 
      MOD_WIN = 0x0008, 
     } 

     [DllImport("user32.dll")] 
     public static extern bool RegisterHotKey(IntPtr wnd, int id, MODKEY mode, Keys vk); 

     [DllImport("user32.dll")] 
     public static extern bool UnregisterHotKey(IntPtr wnd, int id); 
    } 
} 

Indicatif téléphonique dans un formulaire ...

private RegisterHotKeyClass _RegisKey = new RegisterHotKeyClass(); 

void _Regis_HotKey() 
{ 
    MessageBox.Show("ok"); 
} 

private void Form1_Load(object sender, EventArgs e) 
{ 
    _RegisKey.Keys = Keys.PrintScreen; 
    _RegisKey.ModKey = 0; 
    _RegisKey.WindowHandle = this.Handle; 
    _RegisKey.HotKey += new RegisterHotKeyClass.HotKeyPass(_Regis_HotKey); 
    _RegisKey.StarHotKey(); 
} 

Answer 2

Voici ma solution pure WPF.

Nous pouvons y parvenir en XAML en utilisant NavigationCommands (namespace: System.Window.Input) classe qui fournit un ensemble standard de commandes de navigation (par exemple NextPage, PagePrécédente, Refresh, chercher, etc.)

approche de mise en œuvre:

on peut donc appeler code personnalisé pour exécuter le rafraîchissement de l'application à l'aide NavigationCommands.Refresh comme

<UserControl.CommandBindings> 
<CommandBinding Command='NavigationCommands.Refresh' 
        Executed="ApplicationRefresh_Executed"> 
</CommandBinding> 
</UserControl.CommandBindings> 

maintenant dans le code derrière classe de UserControl nous pouvons définir comme méthode

private void ApplicationRefresh_Executed(object sender, ExecutedRoutedEventArgs e) 
{ 
      // Implementation goes here. 
}