pinvoke.net: Edit: user32.EnumWindows

@msdn=http://search.microsoft.com/search/results.aspx?qu=$$$
@pinvoke=http://pinvoke.net/$$$.htm

Summary: The EnumWindows API

!!!!C# Signature:
 [DllImport("user32.dll")]
 [return: MarshalAs(UnmanagedType.Bool)]
 static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);

!!!!VB.NET Signature:
 <DllImport("user32.dll", SetLastError:=True, CharSet:=CharSet.Auto)> _
 Private Shared Function EnumWindows(
 ByVal lpEnumFunc As EnumWindowsProc, _
 ByVal lParam As IntPtr) As Boolean
 End Function

!!!!User-Defined Types:
EnumWindowsProc

!!!!Notes:
Callback EnumWindowsProc should return true to continue enumerating or false to stop.
!!!!Tips & Tricks:
The corresponding unmanaged return type is a 4-byte Win32 'BOOL', so mark the method with the MarshalAsAttribute(UnmanagedType.Bool).

!!!Great sample using managed code and a delegate type for the call back from MSDN:
http://msdn2.microsoft.com/en-us/library/d186xcf0(VS.71).aspx

!!SAMPLE CODE!!

using System.Runtime.InteropServices;

public delegate bool CallBackPtr(int hwnd, int lParam);
 private CallBackPtr callBackPtr;

public class EnumReport 
 {
 	[DllImport("user32.dll")]
 	private static extern int EnumWindows(CallBackPtr callPtr, int lPar);

public static bool Report(int hwnd, int lParam) 
	{ 
		Console.WriteLine("Window handle is "+hwnd);
		return true;
	}
 }
 static void Main()
 {

// note in other situations, it is important to keep 
         // callBackPtr as a member variable so it doesnt GC while you're calling EnumWindows
         
         callBackPtr = new CallBackPtr(EnumReport.Report);  
 	EnumReport.EnumWindows(callBackPtr, 0);
 }

!!Sample Code 2 (C#):

public delegate bool EnumedWindow(IntPtr handleWindow, ArrayList handles);
      
      [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
      [return: MarshalAs(UnmanagedType.Bool)]
      public static extern bool EnumWindows(EnumedWindow lpEnumFunc, ArrayList lParam);

public static ArrayList GetWindows()
      {        
         ArrayList windowHandles = new ArrayList();
         EnumedWindow callBackPtr = GetWindowHandle;
         EnumWindows(callBackPtr, windowHandles);

return windowHandles;         
      }

private static bool GetWindowHandle(IntPtr windowHandle, ArrayList windowHandles)
      {
         windowHandles.Add(windowHandle);
         return true;
      }

!!Sample code demonstrating the passing of an object to the enum proc
Oftentimes you'll want to have the EnumProc retrieve some data from a particular window and return it.
You can do this by:
	* Defining a class to hold your custom data, and 
	* Using a ref to that class in the EnumWindows() signature.

using System.Runtime.InteropServices;
 using System.Text;

public class WndSearcher
 {
	public static IntPtr SearchForWindow(string wndclass, string title)
	{
		SearchData sd = new SearchData { Wndclass=wndclass, Title=title };
		EnumWindows(new EnumWindowsProc(EnumProc), ref sd);
		return sd.hWnd;
	}

public static bool EnumProc(IntPtr hWnd, ref SearchData data)
	{
		// Check classname and title 
		// This is different from FindWindow() in that the code below allows partial matches
		StringBuilder sb = new StringBuilder(1024);
		GetClassName(hWnd, sb, sb.Capacity);
		if (sb.ToString().StartsWith(data.Wndclass))
		{
			sb = new StringBuilder(1024);
			GetWindowText(hWnd, sb, sb.Capacity);
			if (sb.ToString().StartsWith(data.Title))
			{
				data.hWnd = hWnd;
				return false;	// Found the wnd, halt enumeration
			}
		}
		return true;
	}

public class SearchData
	{
		// You can put any dicks or Doms in here...
		public string Wndclass;
		public string Title;
		public IntPtr hWnd;
	}

private delegate bool EnumWindowsProc(IntPtr hWnd, ref SearchData data);

[DllImport("user32.dll")]
	[return: MarshalAs(UnmanagedType.Bool)]
	private static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, ref SearchData data);

[DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
	public static extern int GetClassName(IntPtr hWnd, StringBuilder lpClassName, int nMaxCount);

[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
	public static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
 }

Then you'd call:
 // If you're viewing this page with IE, this *should* return the hwnd of the browser
 IntPtr hWnd = WndSearcher.SearchForWindow("IEFrame", "pinvoke.net: EnumWindows");

!!!!Alternative Managed API:

The ManagedWindowsApi project (http://mwinapi.sourceforge.net) provides a static

method ManagedWinapi.Windows.SystemWindow.FilterToplevelWindows().

Documentation: EnumWindows@msdn on MSDN

!!! Note:
There are syntax errors in the above code!
callBackPtr declared outside class EnumReport which is illegal !
Main() declared outside class EnumReport which is illegal !
After correction create an object of EnumReport class and call the functions using the object!
Contact me at -- shrijit1991[at-the-rate-symbol]gmail.com
If you feel that what I have written is wrong, feel free to remove it and drop a mail to me stating reasons for the same
so that I can learn from my mistakes. - Thanks (Shrijit).

The correct signature for EnumWindows in the example:
         [DllImport("user32.Dll")]
         [return: MarshalAs(UnmanagedType.Bool)]
         public static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, [MarshalAsAttribute(UnmanagedType.Struct)] ref SearchData data);
(mirelvv)

I never could get the compiler to accept this format. When called I'd get an error on the "ref SearchData" part. I worked around this by reverting the signature back to "int lParam", then using a member variable to hold the SearchData info. It's not pretty, but accomplishes the same thing.
(acg)