• 0

[C#] How should I use ITaskbarList and how to detect program start?


Question

Hi, I cannot figure out and I also had no luck with google so I'm asking for your help...

I'd like to edit the taskbar buttons and I know (found in the VS Documentation) that I need the ITaskbarList interface but I don't no quite how to use such a unmanaged interface in C#... can you help?

The second question is: how can I detect that a program was launched (or started) in C#? I tried with a lot of WM_messages but I just can't catch this event... I also tested some hooks and so on, but it seems to catch only the program's own WM_CEATE message... how can I catch other programs' messages in my app?

The third question: how can I catch mouse move event outside of my app? As soon as the cursor leaves my app I receive no new messages from the system... there has to be some way to do it, like in SnagIt for example etc

7 answers to this question

Recommended Posts

  • 0

ok, so let's forget C# for a while... I'd like to know the concept how it works...

this is exacly what I've tried to do, I used the SetWindowsHookEx funtion and I hooked all the possible functions but they catch only messages of my own program... I suppose I use the wrong window handles, I mean this hwnd variables, but I can't find the right one

do you know what else do I need to be able to catch all messages? like moving the cursor outside of my app, or that some other program was started?

  • 0

You need to setup global hooks. This is the code I use to check for system events. Included are events for window creating / destroying, minimizing and foreground changes. It should give a good example if you need to include something else.

using System;
using System.ComponentModel;
using System.Runtime.InteropServices;

namespace Four13Designs
{
	public delegate void OnWindowMinimizeStartDelegate(IntPtr hWnd);
	public delegate void OnWindowMinimizeEndDelegate(IntPtr hWnd);
	public delegate void OnWindowForegroundChangedDelegate(IntPtr hWnd);
	public delegate void OnWindowDestroyDelegate(IntPtr hWnd);
	public delegate void OnWindowCreateDelegate(IntPtr hWnd);

	public sealed class Hooks
	{
		#region Windows API

		private enum SystemEvents : uint
		{
			EVENT_SYSTEM_CREATE = 3,
			EVENT_SYSTEM_DESTROY = 0x8001,
			EVENT_SYSTEM_MINIMIZESTART = 0x0016,
			EVENT_SYSTEM_MINIMIZEEND = 0x0017,
			EVENT_SYSTEM_FOREGROUND = 0x0003
		}

		private const uint WINEVENT_OUTOFCONTEXT = 0x0000;

		private delegate void WinEventDelegate(
			IntPtr hWinEventHook,
			uint eventType,
			IntPtr hWnd,
			int idObject,
			int idChild,
			uint dwEventThread,
			uint dwmsEventTime);

		[DllImport("User32.dll", SetLastError = true)]
		private static extern IntPtr SetWinEventHook(
			uint eventMin,
			uint eventMax,
			IntPtr hmodWinEventProc,
			WinEventDelegate lpfnWinEventProc,
			uint idProcess,
			uint idThread,
			uint dwFlags);

		[DllImport("user32.dll")]
		private static extern bool UnhookWinEvent(
			IntPtr hWinEventHook
			);

		#endregion

		private WinEventDelegate dEvent;
		private IntPtr pHook;
		public OnWindowMinimizeStartDelegate OnWindowMinimizeStart;
		public OnWindowMinimizeEndDelegate OnWindowMinimizeEnd;
		public OnWindowForegroundChangedDelegate OnWindowForegroundChanged;
		public OnWindowDestroyDelegate OnWindowDestroy;
		public OnWindowCreateDelegate OnWindowCreate;

		public Hooks()
		{
			dEvent = this.WinEvent;
			pHook = SetWinEventHook(
				(uint)SystemEvents.EVENT_SYSTEM_FOREGROUND,
				(uint)SystemEvents.EVENT_SYSTEM_DESTROY,
				IntPtr.Zero,
				dEvent,
				0,
				0,
				WINEVENT_OUTOFCONTEXT
				);

			if (IntPtr.Zero.Equals(pHook)) throw new Win32Exception();

			GC.KeepAlive(dEvent);
		}

		private void WinEvent(IntPtr hWinEventHook, uint eventType, IntPtr hWnd, int idObject, int idChild, uint dwEventThread, uint dwmsEventTime)
		{
			switch (eventType)
			{
				case (uint)SystemEvents.EVENT_SYSTEM_DESTROY:
					if (OnWindowDestroy != null) OnWindowDestroy(hWnd);
					break;
				case (uint)SystemEvents.EVENT_SYSTEM_FOREGROUND:
					if (OnWindowForegroundChanged != null) OnWindowForegroundChanged(hWnd);
					break;
				case (uint)SystemEvents.EVENT_SYSTEM_MINIMIZESTART:
					if (OnWindowMinimizeStart != null) OnWindowMinimizeStart(hWnd);
					break;
				case (uint)SystemEvents.EVENT_SYSTEM_MINIMIZEEND:
					if (OnWindowMinimizeEnd != null) OnWindowMinimizeEnd(hWnd);
					break;
				default:
					break;
			}
		}

		~Hooks()
		{
			if (!IntPtr.Zero.Equals(pHook)) UnhookWinEvent(pHook);
			pHook = IntPtr.Zero;
			dEvent = null;

			OnWindowCreate = null;
			OnWindowDestroy = null;
			OnWindowForegroundChanged = null;
			OnWindowMinimizeStart = null;
			OnWindowMinimizeEnd = null;
		}
	}
}

And this is the code I use for mouse / keyboard hooking:

using System;
using System.Runtime.InteropServices;
using System.Reflection;
using System.Threading;
using System.Windows.Forms;
using System.ComponentModel;

namespace gma.System.Windows
{
	/// <summary>
	/// This class allows you to tap keyboard and mouse and / or to detect their activity even when an 
	/// application runes in background or does not have any user interface at all. This class raises 
	/// common .NET events with KeyEventArgs and MouseEventArgs so you can easily retrive any information you need.
	/// </summary>
	public class UserActivityHook
	{
		#region Windows structure definitions

		/// <summary>
		/// The POINT structure defines the x- and y- coordinates of a point. 
		/// </summary>
		/// <remarks>
		/// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/gdi/rectangl_0tiq.asp
		/// </remarks>
		[StructLayout(LayoutKind.Sequential)]
		private class POINT
		{
			/// <summary>
			/// Specifies the x-coordinate of the point. 
			/// </summary>
			public int x;
			/// <summary>
			/// Specifies the y-coordinate of the point. 
			/// </summary>
			public int y;
		}

		/// <summary>
		/// The MOUSEHOOKSTRUCT structure contains information about a mouse event passed to a WH_MOUSE hook procedure, MouseProc. 
		/// </summary>
		/// <remarks>
		/// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/windowing/hooks/hookreference/hookstructures/cwpstruct.asp
		/// </remarks>
		[StructLayout(LayoutKind.Sequential)]
		private class MouseHookStruct
		{
			/// <summary>
			/// Specifies a POINT structure that contains the x- and y-coordinates of the cursor, in screen coordinates. 
			/// </summary>
			public POINT pt;
			/// <summary>
			/// Handle to the window that will receive the mouse message corresponding to the mouse event. 
			/// </summary>
			public int hwnd;
			/// <summary>
			/// Specifies the hit-test value. For a list of hit-test values, see the description of the WM_NCHITTEST message. 
			/// </summary>
			public int wHitTestCode;
			/// <summary>
			/// Specifies extra information associated with the message. 
			/// </summary>
			public int dwExtraInfo;
		}

		/// <summary>
		/// The MSLLHOOKSTRUCT structure contains information about a low-level keyboard input event. 
		/// </summary>
		[StructLayout(LayoutKind.Sequential)]
		private class MouseLLHookStruct
		{
			/// <summary>
			/// Specifies a POINT structure that contains the x- and y-coordinates of the cursor, in screen coordinates. 
			/// </summary>
			public POINT pt;
			/// <summary>
			/// If the message is WM_MOUSEWHEEL, the high-order word of this member is the wheel delta. 
			/// The low-order word is reserved. A positive value indicates that the wheel was rotated forward, 
			/// away from the user; a negative value indicates that the wheel was rotated backward, toward the user. 
			/// One wheel click is defined as WHEEL_DELTA, which is 120. 
			///If the message is WM_XBUTTONDOWN, WM_XBUTTONUP, WM_XBUTTONDBLCLK, WM_NCXBUTTONDOWN, WM_NCXBUTTONUP,
			/// or WM_NCXBUTTONDBLCLK, the high-order word specifies which X button was pressed or released, 
			/// and the low-order word is reserved. This value can be one or more of the following values. Otherwise, mouseData is not used. 
			///XBUTTON1
			///The first X button was pressed or released.
			///XBUTTON2
			///The second X button was pressed or released.
			/// </summary>
			public int mouseData;
			/// <summary>
			/// Specifies the event-injected flag. An application can use the following value to test the mouse flags. Value Purpose 
			///LLMHF_INJECTED Test the event-injected flag.  
			///0
			///Specifies whether the event was injected. The value is 1 if the event was injected; otherwise, it is 0.
			///1-15
			///Reserved.
			/// </summary>
			public int flags;
			/// <summary>
			/// Specifies the time stamp for this message.
			/// </summary>
			public int time;
			/// <summary>
			/// Specifies extra information associated with the message. 
			/// </summary>
			public int dwExtraInfo;
		}


		/// <summary>
		/// The KBDLLHOOKSTRUCT structure contains information about a low-level keyboard input event. 
		/// </summary>
		/// <remarks>
		/// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/windowing/hooks/hookreference/hookstructures/cwpstruct.asp
		/// </remarks>
		[StructLayout(LayoutKind.Sequential)]
		private class KeyboardHookStruct
		{
			/// <summary>
			/// Specifies a virtual-key code. The code must be a value in the range 1 to 254. 
			/// </summary>
			public int vkCode;
			/// <summary>
			/// Specifies a hardware scan code for the key. 
			/// </summary>
			public int scanCode;
			/// <summary>
			/// Specifies the extended-key flag, event-injected flag, context code, and transition-state flag.
			/// </summary>
			public int flags;
			/// <summary>
			/// Specifies the time stamp for this message.
			/// </summary>
			public int time;
			/// <summary>
			/// Specifies extra information associated with the message. 
			/// </summary>
			public int dwExtraInfo;
		}
		#endregion

		#region Windows function imports
		/// <summary>
		/// The SetWindowsHookEx function 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="idHook">
		/// [in] Specifies the type of hook procedure to be installed. This parameter can be one of the following values.
		/// </param>
		/// <param name="lpfn">
		/// [in] Pointer to the hook procedure. If the dwThreadId parameter is zero or specifies the identifier of a 
		/// thread created by a different process, the lpfn parameter must point to a hook procedure in a dynamic-link 
		/// library (DLL). Otherwise, lpfn can point to a hook procedure in the code associated with the current process.
		/// </param>
		/// <param name="hMod">
		/// [in] Handle to the DLL containing the hook procedure pointed to by the lpfn parameter. 
		/// The hMod parameter must be set to NULL if the dwThreadId parameter specifies a thread created by 
		/// the current process and if the hook procedure is within the code associated with the current process. 
		/// </param>
		/// <param name="dwThreadId">
		/// [in] Specifies the identifier of the thread with which the hook procedure is to be associated. 
		/// If this parameter is zero, the hook procedure is associated with all existing threads running in the 
		/// same desktop as the calling thread. 
		/// </param>
		/// <returns>
		/// If the function succeeds, the return value is the handle to the hook procedure.
		/// If the function fails, the return value is NULL. To get extended error information, call GetLastError.
		/// </returns>
		/// <remarks>
		/// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/windowing/hooks/hookreference/hookfunctions/setwindowshookex.asp
		/// </remarks>
		[DllImport("user32.dll", CharSet = CharSet.Auto,
		   CallingConvention = CallingConvention.StdCall, SetLastError = true)]
		private static extern int SetWindowsHookEx(
			int idHook,
			HookProc lpfn,
			IntPtr hMod,
			int dwThreadId);

		/// <summary>
		/// The UnhookWindowsHookEx function removes a hook procedure installed in a hook chain by the SetWindowsHookEx function. 
		/// </summary>
		/// <param name="idHook">
		/// [in] Handle to the hook to be removed. This parameter is a hook handle obtained by a previous call to SetWindowsHookEx. 
		/// </param>
		/// <returns>
		/// If the function succeeds, the return value is nonzero.
		/// If the function fails, the return value is zero. To get extended error information, call GetLastError.
		/// </returns>
		/// <remarks>
		/// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/windowing/hooks/hookreference/hookfunctions/setwindowshookex.asp
		/// </remarks>
		[DllImport("user32.dll", CharSet = CharSet.Auto,
			CallingConvention = CallingConvention.StdCall, SetLastError = true)]
		private static extern int UnhookWindowsHookEx(int idHook);

		/// <summary>
		/// The CallNextHookEx function passes the hook information to the next hook procedure in the current hook chain. 
		/// A hook procedure can call this function either before or after processing the hook information. 
		/// </summary>
		/// <param name="idHook">Ignored.</param>
		/// <param name="nCode">
		/// [in] Specifies the hook code passed to the current hook procedure. 
		/// The next hook procedure uses this code to determine how to process the hook information.
		/// </param>
		/// <param name="wParam">
		/// [in] Specifies the wParam value passed to the current hook procedure. 
		/// The meaning of this parameter depends on the type of hook associated with the current hook chain. 
		/// </param>
		/// <param name="lParam">
		/// [in] Specifies the lParam value passed to the current hook procedure. 
		/// The meaning of this parameter depends on the type of hook associated with the current hook chain. 
		/// </param>
		/// <returns>
		/// This value is returned by the next hook procedure in the chain. 
		/// The current hook procedure must also return this value. The meaning of the return value depends on the hook type. 
		/// For more information, see the descriptions of the individual hook procedures.
		/// </returns>
		/// <remarks>
		/// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/windowing/hooks/hookreference/hookfunctions/setwindowshookex.asp
		/// </remarks>
		[DllImport("user32.dll", CharSet = CharSet.Auto,
			 CallingConvention = CallingConvention.StdCall)]
		private static extern int CallNextHookEx(
			int idHook,
			int nCode,
			int wParam,
			IntPtr lParam);

		/// <summary>
		/// The CallWndProc hook procedure is an application-defined or library-defined callback 
		/// function used with the SetWindowsHookEx function. The HOOKPROC type defines a pointer 
		/// to this callback function. CallWndProc is a placeholder for the application-defined 
		/// or library-defined function name.
		/// </summary>
		/// <param name="nCode">
		/// [in] Specifies whether the hook procedure must process the message. 
		/// If nCode is HC_ACTION, the hook procedure must process the message. 
		/// If nCode is less than zero, the hook procedure must pass the message to the 
		/// CallNextHookEx function without further processing and must return the 
		/// value returned by CallNextHookEx.
		/// </param>
		/// <param name="wParam">
		/// [in] Specifies whether the message was sent by the current thread. 
		/// If the message was sent by the current thread, it is nonzero; otherwise, it is zero. 
		/// </param>
		/// <param name="lParam">
		/// [in] Pointer to a CWPSTRUCT structure that contains details about the message. 
		/// </param>
		/// <returns>
		/// If nCode is less than zero, the hook procedure must return the value returned by CallNextHookEx. 
		/// If nCode is greater than or equal to zero, it is highly recommended that you call CallNextHookEx 
		/// and return the value it returns; otherwise, other applications that have installed WH_CALLWNDPROC 
		/// hooks will not receive hook notifications and may behave incorrectly as a result. If the hook 
		/// procedure does not call CallNextHookEx, the return value should be zero. 
		/// </returns>
		/// <remarks>
		/// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/windowing/hooks/hookreference/hookfunctions/callwndproc.asp
		/// </remarks>
		private delegate int HookProc(int nCode, int wParam, IntPtr lParam);

		/// <summary>
		/// The ToAscii function translates the specified virtual-key code and keyboard 
		/// state to the corresponding character or characters. The function translates the code 
		/// using the input language and physical keyboard layout identified by the keyboard layout handle.
		/// </summary>
		/// <param name="uVirtKey">
		/// [in] Specifies the virtual-key code to be translated. 
		/// </param>
		/// <param name="uScanCode">
		/// [in] Specifies the hardware scan code of the key to be translated. 
		/// The high-order bit of this value is set if the key is up (not pressed). 
		/// </param>
		/// <param name="lpbKeyState">
		/// [in] Pointer to a 256-byte array that contains the current keyboard state. 
		/// Each element (byte) in the array contains the state of one key. 
		/// If the high-order bit of a byte is set, the key is down (pressed). 
		/// The low bit, if set, indicates that the key is toggled on. In this function, 
		/// only the toggle bit of the CAPS LOCK key is relevant. The toggle state 
		/// of the NUM LOCK and SCROLL LOCK keys is ignored.
		/// </param>
		/// <param name="lpwTransKey">
		/// [out] Pointer to the buffer that receives the translated character or characters. 
		/// </param>
		/// <param name="fuState">
		/// [in] Specifies whether a menu is active. This parameter must be 1 if a menu is active, or 0 otherwise. 
		/// </param>
		/// <returns>
		/// If the specified key is a dead key, the return value is negative. Otherwise, it is one of the following values. 
		/// Value Meaning 
		/// 0 The specified virtual key has no translation for the current state of the keyboard. 
		/// 1 One character was copied to the buffer. 
		/// 2 Two characters were copied to the buffer. This usually happens when a dead-key character 
		/// (accent or diacritic) stored in the keyboard layout cannot be composed with the specified 
		/// virtual key to form a single character. 
		/// </returns>
		/// <remarks>
		/// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/userinput/keyboardinput/keyboardinputreference/keyboardinputfunctions/toascii.asp
		/// </remarks>
		[DllImport("user32")]
		private static extern int ToAscii(
			int uVirtKey,
			int uScanCode,
			byte[] lpbKeyState,
			byte[] lpwTransKey,
			int fuState);

		/// <summary>
		/// The GetKeyboardState function copies the status of the 256 virtual keys to the 
		/// specified buffer. 
		/// </summary>
		/// <param name="pbKeyState">
		/// [in] Pointer to a 256-byte array that contains keyboard key states. 
		/// </param>
		/// <returns>
		/// If the function succeeds, the return value is nonzero.
		/// If the function fails, the return value is zero. To get extended error information, call GetLastError. 
		/// </returns>
		/// <remarks>
		/// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/userinput/keyboardinput/keyboardinputreference/keyboardinputfunctions/toascii.asp
		/// </remarks>
		[DllImport("user32")]
		private static extern int GetKeyboardState(byte[] pbKeyState);

		[DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
		private static extern short GetKeyState(int vKey);

		#endregion

		#region Windows constants

		//values from Winuser.h in Microsoft SDK.
		/// <summary>
		/// Windows NT/2000/XP: Installs a hook procedure that monitors low-level mouse input events.
		/// </summary>
		private const int WH_MOUSE_LL	   = 14;
		/// <summary>
		/// Windows NT/2000/XP: Installs a hook procedure that monitors low-level keyboard  input events.
		/// </summary>
		private const int WH_KEYBOARD_LL	= 13;

		/// <summary>
		/// Installs a hook procedure that monitors mouse messages. For more information, see the MouseProc hook procedure. 
		/// </summary>
		private const int WH_MOUSE		  = 7;
		/// <summary>
		/// Installs a hook procedure that monitors keystroke messages. For more information, see the KeyboardProc hook procedure. 
		/// </summary>
		private const int WH_KEYBOARD	   = 2;

		/// <summary>
		/// The WM_MOUSEMOVE message is posted to a window when the cursor moves. 
		/// </summary>
		private const int WM_MOUSEMOVE	  = 0x200;
		/// <summary>
		/// The WM_LBUTTONDOWN message is posted when the user presses the left mouse button 
		/// </summary>
		private const int WM_LBUTTONDOWN	= 0x201;
		/// <summary>
		/// The WM_RBUTTONDOWN message is posted when the user presses the right mouse button
		/// </summary>
		private const int WM_RBUTTONDOWN	= 0x204;
		/// <summary>
		/// The WM_MBUTTONDOWN message is posted when the user presses the middle mouse button 
		/// </summary>
		private const int WM_MBUTTONDOWN	= 0x207;
		/// <summary>
		/// The WM_LBUTTONUP message is posted when the user releases the left mouse button 
		/// </summary>
		private const int WM_LBUTTONUP	  = 0x202;
		/// <summary>
		/// The WM_RBUTTONUP message is posted when the user releases the right mouse button 
		/// </summary>
		private const int WM_RBUTTONUP	  = 0x205;
		/// <summary>
		/// The WM_MBUTTONUP message is posted when the user releases the middle mouse button 
		/// </summary>
		private const int WM_MBUTTONUP	  = 0x208;
		/// <summary>
		/// The WM_LBUTTONDBLCLK message is posted when the user double-clicks the left mouse button 
		/// </summary>
		private const int WM_LBUTTONDBLCLK  = 0x203;
		/// <summary>
		/// The WM_RBUTTONDBLCLK message is posted when the user double-clicks the right mouse button 
		/// </summary>
		private const int WM_RBUTTONDBLCLK  = 0x206;
		/// <summary>
		/// The WM_RBUTTONDOWN message is posted when the user presses the right mouse button 
		/// </summary>
		private const int WM_MBUTTONDBLCLK  = 0x209;
		/// <summary>
		/// The WM_MOUSEWHEEL message is posted when the user presses the mouse wheel. 
		/// </summary>
		private const int WM_MOUSEWHEEL	 = 0x020A;

		/// <summary>
		/// The WM_KEYDOWN message is posted to the window with the keyboard focus when a nonsystem 
		/// key is pressed. A nonsystem key is a key that is pressed when the ALT key is not pressed.
		/// </summary>
		private const int WM_KEYDOWN = 0x100;
		/// <summary>
		/// The WM_KEYUP message is posted to the window with the keyboard focus when a nonsystem 
		/// key is released. A nonsystem key is a key that is pressed when the ALT key is not pressed, 
		/// or a keyboard key that is pressed when a window has the keyboard focus.
		/// </summary>
		private const int WM_KEYUP = 0x101;
		/// <summary>
		/// The WM_SYSKEYDOWN message is posted to the window with the keyboard focus when the user 
		/// presses the F10 key (which activates the menu bar) or holds down the ALT key and then 
		/// presses another key. It also occurs when no window currently has the keyboard focus; 
		/// in this case, the WM_SYSKEYDOWN message is sent to the active window. The window that 
		/// receives the message can distinguish between these two contexts by checking the context 
		/// code in the lParam parameter. 
		/// </summary>
		private const int WM_SYSKEYDOWN = 0x104;
		/// <summary>
		/// The WM_SYSKEYUP message is posted to the window with the keyboard focus when the user 
		/// releases a key that was pressed while the ALT key was held down. It also occurs when no 
		/// window currently has the keyboard focus; in this case, the WM_SYSKEYUP message is sent 
		/// to the active window. The window that receives the message can distinguish between 
		/// these two contexts by checking the context code in the lParam parameter. 
		/// </summary>
		private const int WM_SYSKEYUP = 0x105;

		private const byte VK_SHIFT	 = 0x10;
		private const byte VK_CAPITAL   = 0x14;
		private const byte VK_NUMLOCK   = 0x90;

		#endregion

		/// <summary>
		/// Creates an instance of UserActivityHook object and sets mouse and keyboard hooks.
		/// </summary>
		/// <exception cref="Win32Exception">Any windows problem.</exception>
		public UserActivityHook()
		{
			Start();
		}

		/// <summary>
		/// Creates an instance of UserActivityHook object and installs both or one of mouse and/or keyboard hooks and starts rasing events
		/// </summary>
		/// <param name="InstallMouseHook"><b>true</b> if mouse events must be monitored</param>
		/// <param name="InstallKeyboardHook"><b>true</b> if keyboard events must be monitored</param>
		/// <exception cref="Win32Exception">Any windows problem.</exception>
		/// <remarks>
		/// To create an instance without installing hooks call new UserActivityHook(false, false)
		/// </remarks>
		public UserActivityHook(bool InstallMouseHook, bool InstallKeyboardHook)
		{
			Start(InstallMouseHook, InstallKeyboardHook);
		}

		/// <summary>
		/// Destruction.
		/// </summary>
		~UserActivityHook()
		{
			//uninstall hooks and do not throw exceptions
			Stop(true, true, false);
		}

		/// <summary>
		/// Occurs when the user moves the mouse, presses any mouse button or scrolls the wheel
		/// </summary>
		public event MouseEventHandler OnMouseActivity;
		/// <summary>
		/// Occurs when the user presses a key
		/// </summary>
		public event KeyEventHandler KeyDown;
		/// <summary>
		/// Occurs when the user presses and releases 
		/// </summary>
		public event KeyPressEventHandler KeyPress;
		/// <summary>
		/// Occurs when the user releases a key
		/// </summary>
		public event KeyEventHandler KeyUp;


		/// <summary>
		/// Stores the handle to the mouse hook procedure.
		/// </summary>
		private int hMouseHook = 0;
		/// <summary>
		/// Stores the handle to the keyboard hook procedure.
		/// </summary>
		private int hKeyboardHook = 0;


		/// <summary>
		/// Declare MouseHookProcedure as HookProc type.
		/// </summary>
		private static HookProc MouseHookProcedure;
		/// <summary>
		/// Declare KeyboardHookProcedure as HookProc type.
		/// </summary>
		private static HookProc KeyboardHookProcedure;


		/// <summary>
		/// Installs both mouse and keyboard hooks and starts rasing events
		/// </summary>
		/// <exception cref="Win32Exception">Any windows problem.</exception>
		public void Start()
		{
			this.Start(true, true);
		}

		/// <summary>
		/// Installs both or one of mouse and/or keyboard hooks and starts rasing events
		/// </summary>
		/// <param name="InstallMouseHook"><b>true</b> if mouse events must be monitored</param>
		/// <param name="InstallKeyboardHook"><b>true</b> if keyboard events must be monitored</param>
		/// <exception cref="Win32Exception">Any windows problem.</exception>
		public void Start(bool InstallMouseHook, bool InstallKeyboardHook)
		{
			// install Mouse hook only if it is not installed and must be installed
			if (hMouseHook == 0 && InstallMouseHook)
			{
				// Create an instance of HookProc.
				MouseHookProcedure = new HookProc(MouseHookProc);
				//install hook
				hMouseHook = SetWindowsHookEx(
					WH_MOUSE_LL,
					MouseHookProcedure,
					Marshal.GetHINSTANCE(
						Assembly.GetExecutingAssembly().GetModules()[0]),
					0);
				//If SetWindowsHookEx fails.
				if (hMouseHook == 0)
				{
					//Returns the error code returned by the last unmanaged function called using platform invoke that has the DllImportAttribute.SetLastError flag set. 
					int errorCode = Marshal.GetLastWin32Error();
					//do cleanup
					Stop(true, false, false);
					//Initializes and throws a new instance of the Win32Exception class with the specified error. 
					throw new Win32Exception(errorCode);
				}
			}

			// install Keyboard hook only if it is not installed and must be installed
			if (hKeyboardHook == 0 && InstallKeyboardHook)
			{
				// Create an instance of HookProc.
				KeyboardHookProcedure = new HookProc(KeyboardHookProc);
				//install hook
				hKeyboardHook = SetWindowsHookEx(
					WH_KEYBOARD_LL,
					KeyboardHookProcedure,
					Marshal.GetHINSTANCE(
					Assembly.GetExecutingAssembly().GetModules()[0]),
					0);
				//If SetWindowsHookEx fails.
				if (hKeyboardHook == 0)
				{
					//Returns the error code returned by the last unmanaged function called using platform invoke that has the DllImportAttribute.SetLastError flag set. 
					int errorCode = Marshal.GetLastWin32Error();
					//do cleanup
					Stop(false, true, false);
					//Initializes and throws a new instance of the Win32Exception class with the specified error. 
					throw new Win32Exception(errorCode);
				}
			}
		}

		/// <summary>
		/// Stops monitoring both mouse and keyboard events and rasing events.
		/// </summary>
		/// <exception cref="Win32Exception">Any windows problem.</exception>
		public void Stop()
		{
			this.Stop(true, true, true);
		}

		/// <summary>
		/// Stops monitoring both or one of mouse and/or keyboard events and rasing events.
		/// </summary>
		/// <param name="UninstallMouseHook"><b>true</b> if mouse hook must be uninstalled</param>
		/// <param name="UninstallKeyboardHook"><b>true</b> if keyboard hook must be uninstalled</param>
		/// <param name="ThrowExceptions"><b>true</b> if exceptions which occured during uninstalling must be thrown</param>
		/// <exception cref="Win32Exception">Any windows problem.</exception>
		public void Stop(bool UninstallMouseHook, bool UninstallKeyboardHook, bool ThrowExceptions)
		{
			//if mouse hook set and must be uninstalled
			if (hMouseHook != 0 && UninstallMouseHook)
			{
				//uninstall hook
				int retMouse = UnhookWindowsHookEx(hMouseHook);
				//reset invalid handle
				hMouseHook = 0;
				//if failed and exception must be thrown
				if (retMouse == 0 && ThrowExceptions)
				{
					//Returns the error code returned by the last unmanaged function called using platform invoke that has the DllImportAttribute.SetLastError flag set. 
					int errorCode = Marshal.GetLastWin32Error();
					//Initializes and throws a new instance of the Win32Exception class with the specified error. 
					throw new Win32Exception(errorCode);
				}
			}

			//if keyboard hook set and must be uninstalled
			if (hKeyboardHook != 0 && UninstallKeyboardHook)
			{
				//uninstall hook
				int retKeyboard = UnhookWindowsHookEx(hKeyboardHook);
				//reset invalid handle
				hKeyboardHook = 0;
				//if failed and exception must be thrown
				if (retKeyboard == 0 && ThrowExceptions)
				{
					//Returns the error code returned by the last unmanaged function called using platform invoke that has the DllImportAttribute.SetLastError flag set. 
					int errorCode = Marshal.GetLastWin32Error();
					//Initializes and throws a new instance of the Win32Exception class with the specified error. 
					throw new Win32Exception(errorCode);
				}
			}
		}


		/// <summary>
		/// A callback function which will be called every time a mouse activity detected.
		/// </summary>
		/// <param name="nCode">
		/// [in] Specifies whether the hook procedure must process the message. 
		/// If nCode is HC_ACTION, the hook procedure must process the message. 
		/// If nCode is less than zero, the hook procedure must pass the message to the 
		/// CallNextHookEx function without further processing and must return the 
		/// value returned by CallNextHookEx.
		/// </param>
		/// <param name="wParam">
		/// [in] Specifies whether the message was sent by the current thread. 
		/// If the message was sent by the current thread, it is nonzero; otherwise, it is zero. 
		/// </param>
		/// <param name="lParam">
		/// [in] Pointer to a CWPSTRUCT structure that contains details about the message. 
		/// </param>
		/// <returns>
		/// If nCode is less than zero, the hook procedure must return the value returned by CallNextHookEx. 
		/// If nCode is greater than or equal to zero, it is highly recommended that you call CallNextHookEx 
		/// and return the value it returns; otherwise, other applications that have installed WH_CALLWNDPROC 
		/// hooks will not receive hook notifications and may behave incorrectly as a result. If the hook 
		/// procedure does not call CallNextHookEx, the return value should be zero. 
		/// </returns>
		private int MouseHookProc(int nCode, int wParam, IntPtr lParam)
		{
			// if ok and someone listens to our events
			if ((nCode >= 0) && (OnMouseActivity != null))
			{
				//Marshall the data from callback.
				MouseLLHookStruct mouseHookStruct = (MouseLLHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseLLHookStruct));

				//detect button clicked
				MouseButtons button = MouseButtons.None;
				short mouseDelta = 0;
				switch (wParam)
				{
					case WM_LBUTTONDOWN:
						//case WM_LBUTTONUP: 
						//case WM_LBUTTONDBLCLK: 
						button = MouseButtons.Left;
						break;
					case WM_RBUTTONDOWN:
						//case WM_RBUTTONUP: 
						//case WM_RBUTTONDBLCLK: 
						button = MouseButtons.Right;
						break;
					case WM_MOUSEWHEEL:
						//If the message is WM_MOUSEWHEEL, the high-order word of mouseData member is the wheel delta. 
						//One wheel click is defined as WHEEL_DELTA, which is 120. 
						//(value >> 16) & 0xffff; retrieves the high-order word from the given 32-bit value
						mouseDelta = (short)((mouseHookStruct.mouseData >> 16) & 0xffff);
						//TODO: X BUTTONS (I havent them so was unable to test)
						//If the message is WM_XBUTTONDOWN, WM_XBUTTONUP, WM_XBUTTONDBLCLK, WM_NCXBUTTONDOWN, WM_NCXBUTTONUP, 
						//or WM_NCXBUTTONDBLCLK, the high-order word specifies which X button was pressed or released, 
						//and the low-order word is reserved. This value can be one or more of the following values. 
						//Otherwise, mouseData is not used. 
						break;
				}

				//double clicks
				int clickCount = 0;
				if (button != MouseButtons.None)
					if (wParam == WM_LBUTTONDBLCLK || wParam == WM_RBUTTONDBLCLK) clickCount = 2;
					else clickCount = 1;

				//generate event 
				 MouseEventArgs e = new MouseEventArgs(
													button,
													clickCount,
													mouseHookStruct.pt.x,
													mouseHookStruct.pt.y,
													mouseDelta);
				//raise it
				OnMouseActivity(this, e);
			}
			//call next hook
			return CallNextHookEx(hMouseHook, nCode, wParam, lParam);
		}

		/// <summary>
		/// A callback function which will be called every time a keyboard activity detected.
		/// </summary>
		/// <param name="nCode">
		/// [in] Specifies whether the hook procedure must process the message. 
		/// If nCode is HC_ACTION, the hook procedure must process the message. 
		/// If nCode is less than zero, the hook procedure must pass the message to the 
		/// CallNextHookEx function without further processing and must return the 
		/// value returned by CallNextHookEx.
		/// </param>
		/// <param name="wParam">
		/// [in] Specifies whether the message was sent by the current thread. 
		/// If the message was sent by the current thread, it is nonzero; otherwise, it is zero. 
		/// </param>
		/// <param name="lParam">
		/// [in] Pointer to a CWPSTRUCT structure that contains details about the message. 
		/// </param>
		/// <returns>
		/// If nCode is less than zero, the hook procedure must return the value returned by CallNextHookEx. 
		/// If nCode is greater than or equal to zero, it is highly recommended that you call CallNextHookEx 
		/// and return the value it returns; otherwise, other applications that have installed WH_CALLWNDPROC 
		/// hooks will not receive hook notifications and may behave incorrectly as a result. If the hook 
		/// procedure does not call CallNextHookEx, the return value should be zero. 
		/// </returns>
		private int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam)
		{
			//indicates if any of underlaing events set e.Handled flag
			bool handled = false;
			//it was ok and someone listens to events
			if ((nCode >= 0) && (KeyDown != null || KeyUp != null || KeyPress != null))
			{
				//read structure KeyboardHookStruct at lParam
				KeyboardHookStruct MyKeyboardHookStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
				//raise KeyDown
				if (KeyDown != null && (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN))
				{
					Keys keyData = (Keys)MyKeyboardHookStruct.vkCode;
					KeyEventArgs e = new KeyEventArgs(keyData);
					KeyDown(this, e);
					handled = handled || e.Handled;
				}

				// raise KeyPress
				if (KeyPress != null && wParam == WM_KEYDOWN)
				{
					bool isDownShift = ((GetKeyState(VK_SHIFT) & 0x80) == 0x80 ? true : false);
					bool isDownCapslock = (GetKeyState(VK_CAPITAL) != 0 ? true : false);

					byte[] keyState = new byte[256];
					GetKeyboardState(keyState);
					byte[] inBuffer = new byte[2];
					if (ToAscii(MyKeyboardHookStruct.vkCode,
							  MyKeyboardHookStruct.scanCode,
							  keyState,
							  inBuffer,
							  MyKeyboardHookStruct.flags) == 1)
					{
						char key = (char)inBuffer[0];
						if ((isDownCapslock ^ isDownShift) && Char.IsLetter(key)) key = Char.ToUpper(key);
						KeyPressEventArgs e = new KeyPressEventArgs(key);
						KeyPress(this, e);
						handled = handled || e.Handled;
					}
				}

				// raise KeyUp
				if (KeyUp != null && (wParam == WM_KEYUP || wParam == WM_SYSKEYUP))
				{
					Keys keyData = (Keys)MyKeyboardHookStruct.vkCode;
					KeyEventArgs e = new KeyEventArgs(keyData);
					KeyUp(this, e);
					handled = handled || e.Handled;
				}

			}

			//if event handled in application do not handoff to other listeners
			if (handled)
				return 1;
			else
				return CallNextHookEx(hKeyboardHook, nCode, wParam, lParam);
		}
	}
}

Just put those two into their own .cs files and call them from your program. From there, to use the system event hook add this to your programs code:

			!<Use this as a global reference

			private Hooks hooks = new Hooks();

			 !<This goes in your Form_Load method

			hooks.OnWindowCreate += new OnWindowCreateDelegate(window_Created);

			!<Now setup the window_Create method and add in the needed coding there. A handle will be passed to the window_Create method.

And to use the mouse hook add this to your program:

			!<Use this as a global reference

			private UserActivityHook actHook = new UserActivityHook(true, false);		   


			!<This goes in your Form_Load method

		   //Create a new event for the gloabl mouse hook
			actHook.OnMouseActivity += new MouseEventHandler(actHook_OnMouseActivity);
			this.actHook.Start(true, false);

Hope it helps. If you need any more help to get it working just let me know and I'll try my best to pass on the knowledge. :)

Edited by Sranshaft
  • 0

@ebody : I`ve also implemented something similar by using Global CBT Hooks to receive Window Create and Activation notifications on a system-wide basis for all windows, so will be happy to help :)

@ Sranshaft,

Excellent bit of code ! However , i have a couple of clarifications with Hook activities :

Basically, i`m working with a group of apps (really complex forms) running as separate exe`s and need to manage their ZOrder & Activation, so that the user gets the "feel" that they are interacting with one,single UI

All these windows are Unowned,Toplevel windows and have WS_EX-TOLLWINDOW style so that they dont show up either in the taskbar or the Alt+Tab menu

In the CBT hook filter functions i basically call SetWindowPos to keep all my app windows together.

  Sranshaft said:
You need to setup global hooks. This is the code I use to check for system events. Included are events for window creating / destroying, minimizing and foreground changes. It should give a good example if you need to include something else.

1. Should the Filter Functions for CBT Global Hooks always be in an unmanaged DLL ? I ask this because u have used C# in the entire sample but how can this get mapped globally into the address space of other unmanaged apps ?

2. Of the two approaches - SetWinEventHookEx or Global CBT Hooks : which one would u suggest is the better alternative? I`m aiming to get stability here and be informed about a wide range of events.

3. Third really important point is that i`m somehow messing up the activation states of the open windows.

Example scenario :

a. Right-click on any of my app windows and a context menu pops up,

b. Without selecting any item on the context menu, click on the taskbar icon of some external app like notepad

c. Click back on my earlier app , but now, the keyboard/mouse focus doesn`t seem to get transferred. Also my app window doesn`t seem to get activated even if i repeatedly click on it (left,right,middle) and i`m sure my hook also doesnt receive any activate notifications.

Is there any way to sync up the activation states ?

Recall that in my hook filter function, i check to see if any of my apps are activated (HCBT_ACTIVATE) and if yes then i change the zorder to bring my windows on top(HWND_TOP) else i send them to the Bottom.

I`m not really sure what more i`m supposed to do in my Filter functions. I tried calling SetActive / Foreground window but that doesn`t really help.

I`m getting the same behavior with SetWineventHook API too, so i guess my zordering code isn`t correct

I can send u a small sample if that helps.

Looking forward to your reply.Any pointers are most appreciated.

  • 0

the documentation is such a mess, I would never expect to find system event functions in the Accessibility group... that's why I couldn't find it earlier,... all the time I was looking for some system category or something hehe... unfortunetally I had no time to test it yet but I think it won't be harder the the window hook function that I tried to use for this purpose till now

This topic is now closed to further replies.
  • Recently Browsing   0 members

    • No registered users viewing this page.
  • Posts

    • Google Maps expands cycling routes and alerts for low-emission zones in Europe by Aditya Tiwari Google announced some new Google Maps updates for users in Europe. These features are meant to help them get around more sustainably and reduce emissions in cities, according to the search giant. For starters, Google is expanding its AI-powered feature that predicts when walking or taking transit will take roughly the same amount of time as driving. Currently available in 60 cities, the feature recommends walking or transit routes and has helped avoid tens of millions of car trips. It will soon launch in Copenhagen, Stockholm, Warsaw, and other cities. Speaking of car trips, Google displays helpful alerts when a car enters an area designated as a low-emission or low-traffic zone in supported cities, such as London and Berlin. It informs users whether their vehicle is permitted in these zones, and they should select an alternative route if necessary. The feature will expand to more than 1,000 low-emission and low-traffic zones across Europe in the coming months, including Italy, Sweden, Austria, and other countries. For those interested in cycling on the roads, Maps will display helpful details about routes in more places. Riders will see bike lanes on their cycling route, as well as other useful information, such as whether there is heavy car traffic or a steep incline ahead. The feature will expand to 17 new cities, including nine in Europe, which will cover about 125,000 km (77,671 miles) of bike lanes globally. Google has partnered with local governments and public authorities in cities such as Hamburg, Madrid, Barcelona, Milan, Rome, Zurich, Budapest, Vienna, and Brussels to source the data. Additionally, Google announced that fuel-efficient routing, also known as eco-friendly routing, is now available globally. As the name suggests, it finds the most fuel or energy-efficient route for your trip. The feature was introduced in 2021, starting with the US, and later expanded to over 40 countries across Europe in its first major update in 2022. On average, about 500 million trips using fuel-efficient routing are taken each month. Google estimated that the feature collectively resulted in "more than 2.7 million metric tons of GHG [greenhouse gas] emissions avoided in 2024 alone," which is equivalent to taking "more than 630,000 gasoline-powered cars off the road for a year."
    • That's one impressive "baby step". Well done!
    • They're already dead. They've been through many rounds off layoffs due to mismanagement and Destiny 2 is basically over as the interest levels are the lowest theyve ever been.
    • Redesigned Windows 11 Start menu: What users wanted and what Microsoft delivered by Taras Buria Windows 11 is getting a redesigned Start menu. This is a big deal for the soon-to-be-four-year-old operating system and its highly controversial design bits. After years of slow to no progress in the Start menu area, Microsoft is finally delivering a much better variant with many new features and plenty of feedback addressed. How much has been addressed? In 2023, we posted a list of the "Top 10 Start menu features and changes Windows 11 users want," so it is now time to compare that to the new Start menu. Note: The new Start menu is not yet publicly available. Microsoft is testing it in Windows 11 preview builds from the Dev and Beta Channels, and you can check out this article to learn how to enable it so that you can try it yourself. 1. Allow users to turn off the "Recommended" section - Delivered (17K+ upvotes) Round of applause for Microsoft, everyone, as the company actually delivered the most requested Start menu feature. The redesigned variant lets you turn off the Recommended section and hide it altogether so that it does not waste any space. Recommended section, begone!2. More customization options - Nope (5.4K+ upvotes) Although Microsoft now allows turning off the Recommended section and switching between three views for the All apps list, the menu remains quite restricted when it comes to personalization, so if you want true customization, Windhawk and the Start menu styler mod are here for you, allowing some seriously cool Start menu designs, as one on the screenshot below: 3. Allow resizing the Start menu - Sort of delivered (3.8K+ upvotes) You still cannot change the size of the Start menu manually like you could in Windows 10. However, the menu is now more adaptive, which means you will see more content if you have a bigger screen. Still, I would like to have the ability to make the menu bigger, so this one remains standing. 4. Go back to the Windows 10-style Start menu - Nope (3.4K+ upvotes) Microsoft is not going back to the Windows 10 Start menu, so if you are one of the 3,400+ people who upvoted this in Feedback Hub, your best course of action is to install a third-party Start menu or just stick to Windows 10. 5. Use Grid view for the All apps list - Delivered (1.5K+ upvotes) Another popular request was delivered fully. I would even say that Microsoft over delivered it. Instead of just killing the standard list view in favor of grid view, Microsoft let users decide what kind of view they want. You can stick to the classic list, switch over to grid view, or enjoy a categorized view. Again, well done! 6. Display jump lists when right-clicking pinned apps - Needs fixing (1K+ upvotes) Microsoft has already fixed this problem, and you can access jump lists and recent files by right-clicking pinned applications in the current Start menu version. However, turning off the Recommended section also turns off jump lists on the Start menu and taskbar for some reason. A very frustrating design for those who use jump lists and do not want the Recommended section. This needs fixing. Microsoft punishes you with no jump lists if you dare to turn off "Recommended." Why?7. Make the Start menu open on the All apps list by default - Delivered (1K+ upvotes) The new Start menu ticks this box as well. There is no need to click "All apps" when you open the Start menu. It now features a single-view user interface with the list of all apps right below your pins and recommendations. All you need to do is start scrolling. 8. Add a full-screen Start menu - Nope (1K+ upvotes) Even though Microsoft "has got this," nothing indicates that the company plans to reintroduce a full-screen Start menu from the days of Windows 10 and Windows 8. A shame, if you ask me. Interestingly, it appears that Microsoft considered a full-screen Start menu for Windows 11. The company recently showed some of the prototypes it considered implementing, including a scrollable full-screen menu. 9. Bring back live tiles - Nope (1K+ upvotes) Tiles are no longer alive. They are as dead as Windows Phone, and there is no return. 10. Make the Start menu button follow the system accent color - Nope (760+ upvotes) Microsoft "has got this," but the blue Start button is here to stay. Do you like what Microsoft did to Windows 11's Start menu? What features are still missing in your opinion? Share your thoughts in the comments.
  • Recent Achievements

    • Week One Done
      slackerzz earned a badge
      Week One Done
    • Week One Done
      vivetool earned a badge
      Week One Done
    • Reacting Well
      pnajbar earned a badge
      Reacting Well
    • Week One Done
      TBithoney earned a badge
      Week One Done
    • First Post
      xuxlix earned a badge
      First Post
  • Popular Contributors

    1. 1
      +primortal
      674
    2. 2
      ATLien_0
      286
    3. 3
      Michael Scrip
      223
    4. 4
      +FloatingFatMan
      195
    5. 5
      Steven P.
      143
  • Tell a friend

    Love Neowin? Tell a friend!