Отлов нажатия NumLock и управление им

[DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
public static extern short GetAsyncKeyState(int vkey);
 
...
 
private void backgroundWorker1_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
{
    while (true)
    {
        short key2 = GetAsyncKeyState(0x90); // А этот клавиши NumLock 
 
        if (key2 != 0)
        {
            if (this.Visible)
            {
                this.Invoke(new MethodInvoker(() => this.Visible = false));
                this.Invoke(new MethodInvoker(() => this.TopMost = true));
            }
            else
                this.Invoke(new MethodInvoker(() => this.Visible = true));
        }
    }
}

static class Program
    {
        /// <summary>
        /// Главная точка входа для приложения.
        /// </summary>
        private const int WH_KEYBOARD_LL = 13;
        private const int WM_KEYDOWN = 0x0100;
        private static LowLevelKeyboardProc _proc = HookCallback;
        private static IntPtr _hookID = IntPtr.Zero;
 
        [STAThread]
        static void Main()
        {
            _hookID = SetHook(_proc);
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
            UnhookWindowsHookEx(_hookID);
        }
 
        private static IntPtr SetHook(LowLevelKeyboardProc proc)//hook
        {
            using (Process curProcess = Process.GetCurrentProcess())
            using (ProcessModule curModule = curProcess.MainModule)
            {
                return SetWindowsHookEx(WH_KEYBOARD_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
            }
        }
 
        private delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);
        static public String DopBtn = "null";
        private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
        {
 
            if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN)
            {
                int vkCode = Marshal.ReadInt32(lParam);
                //MessageBox.Show(( (Keys)vkCode ).ToString(), "Goalchts.at.ua"); // Вот сними комментарии к етой сроке, нажми на кепс лук, и увидиш какая клавиша была нажата!
                #region press
                    #region dop
                    if (vkCode == 162)
                    {
                        DopBtn = "LControlKey";
                    }
                    if (vkCode == 160)
                    {
                        DopBtn = "LShiftKey";
                    }
                    #endregion
                    if (TestKeys.Form1.DoMas.Length > 1)//activate macro
                        for (int i = 0; i < TestKeys.Form1.DoMas.Length-1; i++)
                            if (((Keys)vkCode).ToString() == TestKeys.Form1.DoMas[i].StartKey2 && DopBtn.Equals(TestKeys.Form1.DoMas[i].StartKey1))
                            {
                                DopBtn = "end";
                                TestKeys.Form1.DoMas[i].PerformKeys(TestKeys.Form1.DoMas[i]);
                                DopBtn = "end";
                            }
                    #region clear_dopBtn
                    if (!((DopBtn.Equals("LControlKey") && !DopBtn.Equals("LShiftKey")) || (!DopBtn.Equals("LControlKey") && DopBtn.Equals("LShiftKey"))))
                    {
                        DopBtn = "xxx";
                    }
                    #endregion
 
                #endregion
 
 
            }
            return CallNextHookEx(_hookID, nCode, wParam, lParam);
        }
 
        #region DLLimport
        [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);
        #endregion
    }

private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
        {
 
             if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN)//проверка на правильность(что б потом ошибка не вылетела, такое бывает)
            {
                int vkCode = Marshal.ReadInt32(lParam);
                MessageBox.Show(( (Keys)vkCode ).ToString(), "Goalchts.at.ua");//каждый раз будет выскакивать окно с названием нажатой клавишы(закомментировать)
                #region press
                    #region dop//установка дополнительных клавиш(контрл и шифт)
                    if (vkCode == 162)
                    {
                        DopBtn = "LControlKey";
                    }
                    if (vkCode == 160)
                    {
                        DopBtn = "LShiftKey";
                    }
                    #endregion
                    if (TestKeys.Form1.DoMas.Length > 1)//activate macro(увы ето уже мое, в каждом екземпляре класса есть переменные старта макро)
                        for (int i = 0; i < TestKeys.Form1.DoMas.Length-1; i++)
                            if (((Keys)vkCode).ToString() == TestKeys.Form1.DoMas[i].StartKey2 && DopBtn.Equals(TestKeys.Form1.DoMas[i].StartKey1))
                            {
                                DopBtn = "end";
                                TestKeys.Form1.DoMas[i].PerformKeys(TestKeys.Form1.DoMas[i]);
                                DopBtn = "end";
                            }
                    #region clear_dopBtn
                    if (!((DopBtn.Equals("LControlKey") && !DopBtn.Equals("LShiftKey")) || (!DopBtn.Equals("LControlKey") && DopBtn.Equals("LShiftKey"))))
                    {
                        DopBtn = "xxx";//очистка дополнительных клавиш
                    }
                    #endregion
 
                #endregion
 
 
            }
              return CallNextHookEx(_hookID, nCode, wParam, lParam);
        }

        private static IntPtr HookProc(int code, IntPtr wParam, IntPtr lParam)
        {
            if ((code >= 0 && wParam == (IntPtr)WH_KEYDOWN) && Marshal.ReadInt32(lParam) == KBD_NUM_LOCK)
            {
                // обрабатываем нажатие нужной клавиши
                MessageBox.Show("NumLock");
                Form1.State(); //Вот тут!
            }
 
            // пробрасываем дальше
            return CallNextHookEx(_hhook, code, (int)wParam, lParam);
        }

        public void State()
        {
            switch( WindowState ) 
            { //Изменил - не помогает, нужна ссылка на нестатический...
                case FormWindowState.Normal:
                    WindowState = FormWindowState.Minimized;
                    break;
                case FormWindowState.Minimized:
                    WindowState = FormWindowState.Normal;
                    break;
            }
        }

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Runtime.InteropServices;
 
namespace Num__
{
    public partial class Form1 : Form
    {
        double c;
        bool status = false;
        bool stat = true;
 
        public Form1()
        {
            InitializeComponent();
 
            Hooks.SetHook();
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            string inString = textBox1.Text;
            if (Checked(inString))
            {
                string outStr = GetExp(inString);
                textBox1.Text += " = " + Reshenie(outStr);
                status = true;
            }
        }
 
        static private bool Checked(string str)
        {
            int sum = 0;
 
            foreach (char ch in str)
            {
                if (ch == '(')
                    sum++;
                if (ch == ')')
                    sum--;
            }
 
            if (sum != 0 || IsOperator(str[0]) || IsOperator(str[str.Length - 1]))
            {
                MessageBox.Show("Error!");
                return false;
            }
            return true;
        }
 
        private double Reshenie(string str)
        {
            Stack<double> resh = new Stack<double>();
 
            for (int i = 0; i < str.Length; i++)
            {
                if (Char.IsDigit(str[i]))
                {
                    string a = "";
 
                    while (!IsDelimetr(str[i])) //Пока не разделитель
                    {
                        a += str[i]; //Добаляем
                        i++;
                        if (i == str.Length) break;
                    }
                    resh.Push(double.Parse(a));
                    i--;
                    continue;
                }
                else if (IsOperator(str[i]))
                {
                    double a = resh.Pop();
                    double b = resh.Pop();
                    switch (str[i])
                    {
 
                        case '+': c = b + a; break;
                        case '-': c = b - a; break;
                        case '*': c = b * a; break;
                        case '/': c = b / a; break;
                        case '^': c = double.Parse(Math.Pow(double.Parse(b.ToString()), double.Parse(a.ToString())).ToString()); break;
                    }
                    resh.Push(c);
                }
            }
 
            return resh.Peek();
        }
 
        private string GetExp(string str)
        {
            string outString = "";
            Stack<char> operStack = new Stack<char>();
 
            for (int i = 0; i < str.Length; i++)
            {
                if (str[i] == ' ') //Если пробел
                    continue; //пропускаем
 
                if (Char.IsDigit(str[i])) //Если число
                {
                    while (!IsDelimetr(str[i])) //Пока не разделитель
                    {
                        outString += str[i]; //Добаляем
                        i++;
                        if (i == str.Length) break;
                    }
                    outString += " ";
                    i--;
                    continue;
                }
 
                if (IsOperator(str[i]))
                {
                    if (operStack.Count > 0)
                        if (GetPriority(str[i]) <= GetPriority(operStack.Peek()))
                            outString += operStack.Pop().ToString() + " ";
 
                    operStack.Push(char.Parse(str[i].ToString()));
                }
 
                if (str[i] == '(')
                    operStack.Push(str[i]);
 
                if (str[i] == ')')
                {
                    char s = operStack.Pop();
 
                    while (s != '(')
                    {
                        outString += s.ToString() + ' '; //Тут была ошибка, вместо операторов добавлялась цифра (75)
                        s = operStack.Pop();
                    }
                }
            }
 
            while (operStack.Count > 0)
                outString += operStack.Pop() + " ";
 
            return outString;
        }
 
        static private bool IsOperator(char с)
        {
            if (("+-/*^".IndexOf(с) != -1))
                return true;
            return false;
        }
 
        private byte GetPriority(char s)
        {
            switch (s)
            {
                case '(':
                    return 0;
                case ')':
                    return 1;
                case '+':
                    return 2;
                case '-':
                    return 3;
                case '*':
                    return 4;
                case '/':
                    return 4;
                case '^':
                    return 5;
                default:
                    return 6;
            }
        }
 
        static private bool IsDelimetr(char c)
        {
            if ((" +-/*^()=".IndexOf(c) != -1))
                return true;
            return false;
        }
 
        private void Form1_KeyDown(object sender, KeyEventArgs e)
        {
            if (status)
            {
                textBox1.Clear();
                status = false;
            }
        }
 
        private void notifyIcon1_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            if (this.Visible)
            {
                this.Visible = false;
            }
            else 
            {
                this.Visible = true;
            }
        }
 
        private void exitButton_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }
 
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            notifyIcon1.Dispose();
        }
 
        public void State()
        {
            switch (WindowsState)
            {
                case FormWindowState.Normal:
                    WindowState = FormWindowState.Minimized;
                    break;
                case FormWindowState.Minimized:
                    WindowState = FormWindowState.Normal;
                    break;
            }
        }
    }
 
    #region Hook
    public static class Hooks
    {
        #region Declare WinAPI functions
        [DllImport("kernel32.dll")]
        private static extern IntPtr LoadLibrary(string lpFileName);
 
        [DllImport("user32.dll")]
        private static extern IntPtr SetWindowsHookEx(int idHook, KeyboardHookProc callback, IntPtr hInstance, uint threadId);
        [DllImport("user32.dll")]
        private static extern IntPtr CallNextHookEx(IntPtr idHook, int nCode, int wParam, IntPtr lParam);
        [DllImport("user32.dll")]
        private static extern bool UnhookWindowsHookEx(IntPtr hInstance);
        #endregion
        #region Constants
        private const int WH_KEYBOARD_LL = 13;
        private const int WH_KEYDOWN = 0x0100;
        // код клавиши на которую ставим хук
        private const int KBD_NUM_LOCK = 0x90;
        #endregion
 
        private delegate IntPtr KeyboardHookProc(int code, IntPtr wParam, IntPtr lParam);
        private static readonly KeyboardHookProc Proc = HookProc;
 
        private static IntPtr _hhook = IntPtr.Zero;
 
        public static void SetHook()
        {
            var hInstance = LoadLibrary("User32");
            _hhook = SetWindowsHookEx(WH_KEYBOARD_LL, Proc, hInstance, 0);
        }
 
        public static void UnHook()
        {
            UnhookWindowsHookEx(_hhook);
        }
 
        private static IntPtr HookProc(int code, IntPtr wParam, IntPtr lParam)
        {
            if ((code >= 0 && wParam == (IntPtr)WH_KEYDOWN) && Marshal.ReadInt32(lParam) == KBD_NUM_LOCK)
            {
                // обрабатываем нажатие нужной клавиши
                MessageBox.Show("NumLock");
                Form1.State();
            }
 
            // пробрасываем дальше
            return CallNextHookEx(_hhook, code, (int)wParam, lParam);
        }
    }
 
    #endregion Hook 
 
}