intercept CTRL + Letter + Letter

Question

I would like to intercept while I push CTRL + A + A

I read the article How can I register a global hot key to say CTRL+SHIFT+(LETTER) using WPF and .NET 3.5?

and someone pasted a code originally posted here: https://www.fluxbytes.com/csharp/how-to-register-a-global-hotkey-for-your-application-in-c/?unapproved=2279&moderation-hash=b3ec34d2621e0be051ed354f09c436d2#comment-2279

Anyway, I tried to change the code adding and "&" but this and some other attempt was wrong.

How can I get if I press CTRL + A + A ?

Thanks for the help!

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

namespace GlobalHotkeyExampleForm
{
    public partial class Form1 : Form
    {

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        [DllImport("user32.dll")]
        private static extern bool RegisterHotKey(IntPtr hWnd, int id, int fsModifiers, int vk);
        [DllImport("user32.dll")]
        private static extern bool UnregisterHotKey(IntPtr hWnd, int id);

        enum KeyModifier
        {
            None = 0,
            Alt = 1,
            Control = 2,
            Shift = 4,
            WinKey = 8
        }

        public Form1()
        {
            InitializeComponent();

            int id = 0;     // The id of the hotkey. 
            RegisterHotKey(this.Handle, id, (int)KeyModifier.Control, Keys.A.GetHashCode());       // Register ctrl + a as global hotkey. 
        }

        protected override void WndProc(ref Message m)
        {
            base.WndProc(ref m);

            if (m.Msg == 0x0312)
            {
                /* Note that the three lines below are not needed if you only want to register one hotkey.
                 * The below lines are useful in case you want to register multiple keys, which you can use a switch with the id as argument, or if you want to know which key/modifier was pressed for some particular reason. */

                Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);                  // The key of the hotkey that was pressed.
                KeyModifier modifier = (KeyModifier)((int)m.LParam & 0xFFFF);       // The modifier of the hotkey that was pressed.
                int id = m.WParam.ToInt32();                                        // The id of the hotkey that was pressed.


                MessageBox.Show("Hotkey has been pressed!");
                // do something
            }
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            UnregisterHotKey(this.Handle, 0);       // Unregister hotkey with id 0 before closing the form. You might want to call this more than once with different id values if you are planning to register more than one hotkey.
        }

        private void button1_Click(object sender, EventArgs e)
        {
            this.Close();
        }
    }
}

Answer 1

Yesterday I'm back on this question and finally, I did what I was searching to do but changing the strategy because with the upper code I didn't really found a solution for my target. I'm going to report why I think it can be useful to someone else and maybe someone has a different solution.

So, on the upper code, I tried to intercept CTRL+C+C and than get what use copy on the Windows Clipboard. But here it's the problem, that code registers the shortkey, so any other software can't continue to use CTRL+C. I tried to unregister the shortkey after to have cached that CTRL+C has been pressed but I've found only problems. Anyway, I don't like "to stole" a shortkey to another app, I prefer to "listen" key while they are pressed.

So here it follows the code with some comments (I'll paste the solution that I've found "listening keys pressed" adding a new answer).

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

namespace GlobalHotkeyExampleForm
{
    public partial class Form1 : Form
    {

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        public int shortkey = 0;

        [DllImport("user32.dll")]
        private static extern bool RegisterHotKey(IntPtr hWnd, int id, int fsModifiers, int vk);
        [DllImport("user32.dll")]
        private static extern bool UnregisterHotKey(IntPtr hWnd, int id);

        enum KeyModifier
        {
            None = 0,
            Alt = 1,
            Control = 2,
            Shift = 4,
            WinKey = 8
        }

        public Form1()
        {
            InitializeComponent();

            int id = 0;     // The id of the hotkey. 
            RegisterHotKey(this.Handle, id, (int)KeyModifier.Control, Keys.C.GetHashCode());       // Register CTRL + C as global hotkey. 
        }

        protected override void WndProc(ref Message m)
        {
            base.WndProc(ref m);

            if (m.Msg == 0x0312)
            {
                /* Note that the three lines below are not needed if you only want to register one hotkey.
                 * The below lines are useful in case you want to register multiple keys, which you can use a switch with the id as argument, or if you want to know which key/modifier was pressed for some particular reason. */

                Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);                  // The key of the hotkey that was pressed.
                KeyModifier modifier = (KeyModifier)((int)m.LParam & 0xFFFF);       // The modifier of the hotkey that was pressed.
                int id = m.WParam.ToInt32();                                        // The id of the hotkey that was pressed.

                if (modifier == KeyModifier.Control && key == Keys.C)
                {
                    shortkey = shortkey + 1;

                    label1.Text = (shortkey.ToString());

                    //if I enebale this code it works partially. The UnregisterHotKey and RegisterHotKey works perfectly and alone also SendKeys works prefectly, but together it doesn't:
                    //it doesn't recognize that CTRL is still pressed and I don't want to do CTRL C + CTRL C and I don't like "to stole" the shortkey from other apps!;
                    //I tried to use SendKeys to resend CTRL C or onlt CTRL but it doens't work and it creates only Register problems 
                    //UnregisterHotKey(this.Handle, 0); //unregister the hotkey catching
                    //SendKeys.Send("^c"); //send key to active application (it doesn't matter if this is the application)               
                    ////register the hotkey catching as C only
                    //RegisterHotKey(this.Handle, id, (int)KeyModifier.Control, Keys.C.GetHashCode());
                    //SendKeys.Send("^c");
                    //SendKeys.Send("^");
                    timer1.Start();
                }

                //MessageBox.Show("Hotkey has been pressed!");
                // do something
            }
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            UnregisterHotKey(this.Handle, 0);       // Unregister hotkey with id 0 before closing the form. You might want to call this more than once with different id values if you are planning to register more than one hotkey.
        }

        private void button1_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        private void timer1_Tick(object sender, EventArgs e)
        {

            if (shortkey == 2)
            {
                string returnMyText = Clipboard.GetText(TextDataFormat.Text);
            }
            shortkey = 0;
            timer1.Stop();
        }
    }
}

Answer 2

This is the solution that I've found to listen Key Pressure. I took the code from "Dylan's Web" and I changed something: https://www.dylansweb.com/2014/10/low-level-global-keyboard-hook-sink-in-c-net/

This is the class with a couple of lines more:

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Input;

namespace DesktopWPFAppLowLevelKeyboardHook
{
    public class LowLevelKeyboardListener
    {
        private const int WH_KEYBOARD_LL = 13;
        private const int WM_KEYDOWN = 0x0100;
        private const int WM_KEYUP = 0x101;
        private const int WM_SYSKEYDOWN = 0x104;
        private const int WM_SYSKEYUP = 0x105;

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool UnhookWindowsHookEx(IntPtr hhk);

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr GetModuleHandle(string lpModuleName);

        public delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);

        public event EventHandler<KeyPressedArgs> OnKeyPressed;

        private LowLevelKeyboardProc _proc;
        private IntPtr _hookID = IntPtr.Zero;

        public LowLevelKeyboardListener()
        {
            _proc = HookCallback;
        }

        public void HookKeyboard()
        {
            _hookID = SetHook(_proc);
        }

        public void UnHookKeyboard()
        {
            UnhookWindowsHookEx(_hookID);
        }

        private IntPtr SetHook(LowLevelKeyboardProc proc)
        {
            using (Process curProcess = Process.GetCurrentProcess())
            using (ProcessModule curModule = curProcess.MainModule)
            {
                return SetWindowsHookEx(WH_KEYBOARD_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
            }
        }

        private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
        {

            if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
            {
                int vkCode = Marshal.ReadInt32(lParam);
                int status = 1;

                if (OnKeyPressed != null) { OnKeyPressed(this, new KeyPressedArgs(KeyInterop.KeyFromVirtualKey(vkCode), status)); }
            }
            else if (nCode >= 0 && wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP)
            {
                int vkCode = Marshal.ReadInt32(lParam);
                int status = 0;

                if (OnKeyPressed != null) { OnKeyPressed(this, new KeyPressedArgs(KeyInterop.KeyFromVirtualKey(vkCode), status)); }
            }

            return CallNextHookEx(_hookID, nCode, wParam, lParam);
        }
    }

    public class KeyPressedArgs : EventArgs
    {
        public Key KeyPressed { get; private set; }
        public int KeyStatus { get; private set; }

        public KeyPressedArgs(Key key, int status)
        {
            KeyPressed = key;
            KeyStatus = status;
        }
    }
}

This is the Form:

using DesktopWPFAppLowLevelKeyboardHook;
using System;
using System.Windows.Forms;

namespace AppLowLevelKeyboardHook
{
    public partial class Form1 : Form
    {
        private LowLevelKeyboardListener _listener;
        public int ctrlStatus;
        public int cStatus;

        public Form1()
        {
            InitializeComponent();
        }

        private void Window_Loaded(object sender, EventArgs e)
        {
            _listener = new LowLevelKeyboardListener();
            _listener.OnKeyPressed += _listener_OnKeyPressed;
            _listener.HookKeyboard();
        }

        private void _listener_OnKeyPressed(object sender, KeyPressedArgs e)
        {
            this.textBox_DisplayKeyboardInput.Text += e.KeyPressed.ToString() + e.KeyStatus.ToString();

            if (e.KeyStatus == 1 && (e.KeyPressed.ToString() == "LeftCtrl" || e.KeyStatus.ToString() == "RightCtrl"))
            {
                if (ctrlStatus == 0)
                {
                    ctrlStatus = ctrlStatus + 1;
                    timer1.Start();
                }
            }
            else if (e.KeyStatus == 1 && e.KeyPressed.ToString() == "C")
            {
                if (ctrlStatus == 1 && (cStatus == 0 || cStatus == 2))
                {
                    cStatus = cStatus + 1;
                }
            }
            //no need to wait that CTRL will be released
            //else if (e.KeyStatus == 0 && (e.KeyPressed.ToString() == "LeftCtrl" || e.KeyStatus.ToString() == "RightCtrl"))
            //{
            //    if (ctrlStatus == 1)
            //    {
            //        ctrlStatus = ctrlStatus + 1;
            //    }
            //}
            else if (e.KeyStatus == 0 && e.KeyPressed.ToString() == "C")
            {
                if (ctrlStatus == 1)
                {
                    if (cStatus == 1 || cStatus == 3)
                    {
                        cStatus = cStatus + 1;
                    }
                }
            }
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            if ((ctrlStatus == 1) && cStatus == 3 || cStatus == 4) //no need to wait that CTRL will be released (ctrlStatus == 2)
            {
                //do something
                label1.Text = "";
                label1.Refresh();
                label1.Text = Clipboard.GetText(TextDataFormat.UnicodeText);
                //\do something
            }
            ctrlStatus = 0;
            cStatus = 0;
            timer1.Stop();
        }

        private void Window_Closing(object sender, FormClosingEventArgs e)
        {
            _listener.UnHookKeyboard();
        }
    }
}

PS: originally it was WPF app but mine it's a WFA and KeyInterop is not included. So I simply added a reference assembly to WindowsBase.dll