Holen Sie sich alle Fenster für einen Prozess

Question

Verwenden von Microsoft Spy ++ behandelt, kann ich sehen, dass die folgenden Fenster, die zu einem Prozess gehören:

Prozess XYZ Fenstergriffe, in Baumform angezeigt wie Spy ++ gibt mir:

A 
    B 
    C 
    D 
E 
F 
    G 
    H 
    I 
    J 
    K 

Ich kann den Prozess abrufen, und die MainWindowHandle-Eigenschaft zeigt auf den Punkt für Fenster F. Wenn ich die untergeordneten Fenster mit aufzählen, kann ich eine Liste der Fenstergriffe für G durch K erhalten, aber ich kann nicht herausfinden, wie finde die Fenstergriffe für A bis D. Wie kann ich Fenster aufzählen, die keine Kinder des Handle sind, das von MainWindowHandle des Process-Objekts angegeben wird?

aufzuzählen ich den win32 Anruf bin mit:

[System.Runtime.InteropServices.DllImport(strUSER32DLL)] 
      public static extern int EnumChildWindows(IntPtr hWnd, WindowCallBack pEnumWindowCallback, int iLParam); 

Answer 1

Pass IntPtr.Zero als hWnd jeden Wurzel Fenstergriff in dem System zu erhalten.

Sie können dann den Eigentümerprozess des Windows überprüfen, indem Sie GetWindowThreadProcessId aufrufen.

Answer 2

Sie können EnumWindows verwenden, um jedes Fenster der obersten Ebene abzurufen, und dann die Ergebnisse basierend auf GetWindowThreadProcessId filtern.

Answer 3

Für alle noch fragen, ist dies die Antwort:

List<IntPtr> GetRootWindowsOfProcess(int pid) 
{ 
    List<IntPtr> rootWindows = GetChildWindows(IntPtr.Zero); 
    List<IntPtr> dsProcRootWindows = new List<IntPtr>(); 
    foreach (IntPtr hWnd in rootWindows) 
    { 
     uint lpdwProcessId; 
     WindowsInterop.User32.GetWindowThreadProcessId(hWnd, out lpdwProcessId); 
     if (lpdwProcessId == pid) 
      dsProcRootWindows.Add(hWnd); 
    } 
    return dsProcRootWindows; 
} 

public static List<IntPtr> GetChildWindows(IntPtr parent) 
{ 
    List<IntPtr> result = new List<IntPtr>(); 
    GCHandle listHandle = GCHandle.Alloc(result); 
    try 
    { 
     WindowsInterop.Win32Callback childProc = new WindowsInterop.Win32Callback(EnumWindow); 
     WindowsInterop.User32.EnumChildWindows(parent, childProc, GCHandle.ToIntPtr(listHandle)); 
    } 
    finally 
    { 
     if (listHandle.IsAllocated) 
      listHandle.Free(); 
    } 
    return result; 
} 

private static bool EnumWindow(IntPtr handle, IntPtr pointer) 
{ 
    GCHandle gch = GCHandle.FromIntPtr(pointer); 
    List<IntPtr> list = gch.Target as List<IntPtr>; 
    if (list == null) 
    { 
     throw new InvalidCastException("GCHandle Target could not be cast as List<IntPtr>"); 
    } 
    list.Add(handle); 
    // You can modify this to check to see if you want to cancel the operation, then return a null here 
    return true; 
} 

für WindowsInterop:

public delegate bool Win32Callback(IntPtr hwnd, IntPtr lParam); 

für WindowsInterop.User32:

[DllImport("user32.dll")] 
public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId); 

[DllImport("user32.Dll")] 
[return: MarshalAs(UnmanagedType.Bool)] 
public static extern bool EnumChildWindows(IntPtr parentHandle, Win32Callback callback, IntPtr lParam); 

Nun kann man einfach jede Wurzel erhalten Fenster von GetRootWindowsOfProcess, und ihre Kinder von GetChildWindows.