Discussion :

[ahage4x4]

Bonjour, je m'explique,
Je dois creer une petite application qui tourne en arriere plan, que ce soit une application console ou Forms.
Quand l'utilisateur windows clique sur une combinaison (CTRL+S par exemple), qu'il soit sur le bureau ou sur n'importe quelle application, je dois reagir sur cet evenement grace a mon application.

Y a t il moyen de le faire? si oui, pourriez vous me guider, je sais intercepter des evenements liés a des composants .NET (Textbox...) mais pas des evenements sur windows en general.

Votre aide sera apprecié, il me faut juste des grandres lignes pour savoir sur quel sujet rechercher de l'info.

Merci

[SirJulio]

Salut,

si c'est juste pour un raccourci, ca se fait tres bien avec quelques fonctions natives. Le principe etant d'enregistrer un raccourci en passant un handle de fenetre (RegisterHotKey dans user32 de memoire), et tu seras notifié par un message dans la fenetre passée en argument par un WM_HOTKEY. Ne pas oublié de liberer le raccourci à la fermetre (UnregisterHotkey).

Il existe un exemple complet de mise en place de raccourci dans la MSDN dans la rubrique Win32.

Voici une source d'une classe representant un raccourci clavier, et implementant IMessageFilter, ainsi qu'un event KeyPressed, que j'avais faite, cela pourra peut etre t'aider.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
    class HotKeyConcrete : Interface.IHotkeyListener
    {
        ushort keyIdentifier;
 
        Keys m_modifiers;
        Keys m_registredKeys;
 
        bool m_state;
 
        public HotKeyConcrete(Keys modifiers, Keys k)
        {
            m_modifiers = modifiers;
            m_registredKeys = k;
        }
 
        IntPtr m_targetHandle;
        public IntPtr FormHandle
        {
            get { return m_targetHandle; }
            set { m_targetHandle = value; }
        }
 
 
        public void Enable()
        {
            if (m_registredKeys > 0 
                && m_targetHandle != null 
                && m_targetHandle != IntPtr.Zero)
            {
                if ((keyIdentifier = GlobalAddAtom(m_registredKeys.ToString() + "Clipboarder")) != 0)
                {
                    int modifiers = 0;
 
                    if ((m_modifiers & Keys.Alt) == Keys.Alt)
                        modifiers |= MOD_ALT;
                    if ((m_modifiers & Keys.Control) == Keys.Control)
                        modifiers |= MOD_CONTROL;
                    if ((m_modifiers & Keys.Shift) == Keys.Shift)
                        modifiers |= MOD_SHIFT;
 
                    Form.FromHandle(m_targetHandle).Invoke(new MethodInvoker(
                        delegate
                        {
                            if (RegisterHotKey(m_targetHandle, keyIdentifier, (int)modifiers, (int)m_registredKeys) != 0)
                                m_state = true;
                        }));
                }
            }
        }
 
        public void Disable()
        {
            if (m_state)
            {
                UnregisterHotKey(m_targetHandle, keyIdentifier);
                GlobalDeleteAtom(keyIdentifier);
 
                keyIdentifier = 0;
 
                m_state = false;
            }
        }
 
        public bool State
        {
            get { return m_state; }
        }
 
        #region IHotkeyListener Members
 
        public event EventHandler HotKeyPressed;
 
        #endregion
 
        #region IMessageFilter Members
 
        public bool PreFilterMessage(ref Message m)
        {
            if (m.Msg == WM_HOTKEY && (ushort)m.WParam == this.keyIdentifier)
            {
                if (HotKeyPressed != null)
                {
                    HotKeyPressed(this, EventArgs.Empty);
                }
                return true;
            }
            return false;
        }
 
 
        string m_name;
        public string Name
        {
            get { return m_name; }
            set { m_name = value; }
        }
 
        #endregion
 
        const int WM_HOTKEY = 0x0312;
 
        const int MOD_ALT = 0x0001;
        const int MOD_CONTROL = 0x0002;
        const int MOD_SHIFT = 0x0004;
 
        [DllImport("user32", SetLastError = true)]
        static extern int RegisterHotKey(IntPtr hwnd, int id, int fsModifiers, int vk);
        [DllImport("user32.dll")]
        static extern bool UnregisterHotKey(IntPtr hWnd, int id);
        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        static extern ushort GlobalAddAtom(string lpString);
        [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
        static extern ushort GlobalDeleteAtom(ushort nAtom);
 
        #region IDisposable Members
 
        public void Dispose()
        {
            Disable();
        }
 
        #endregion
    }

L'interface si besoin est :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    public interface IHotkeyListener : IMessageFilter, IDisposable
    {
        event EventHandler HotKeyPressed;
 
        void Enable();
 
        void Disable();
 
        IntPtr FormHandle { get; set; }
 
        bool State { get; }
 
        string Name { get; set; }
    }

Les AddAtoms et DeleteAtoms sont utilisés pour créer un identifiant pour le raccourci, à la fois pour l'enregistrer, mais aussi pour la differencier dans la notif WM_HOTKEY.

Enfin si ta capture concerne de plus gros volumes de frappes, il faudra sans doute passer par un hook clavier. A noter aussi, que cette facon de faire, obliges à avoir une Form a un moment ou à un autre (tu n'es bien sur pas obligé de l'afficher, et elle peut juste servir de receptrice de message).

Bon courage.

[ahage4x4]

Merci bcp pour ces infos, j'étudie ça en détail ...