Getting Child Windows Using Process.GetProc ess

[TomLasky]

Hi everyone, I ran into a road block and cant seem to find anything on google.

I need to check all open windows/processes to see if certain software is running on the system. I was going to go the route of using core api from user32 for findwindow and so on, but then I came across using Process.Getproc esses and was very happy to see it was easy to get all processes and MainWindowTitle

        Dim poc() As Process = Process.GetProcesses()
        For i As Integer = 0 To poc.Length - 1
 
            Try
                msgbox poc(i).mainwindowtitle
 
            Catch ex As Exception
                MsgBox(poc(i).ProcessName.ToString & " " & ex.Message)
 
            End Try
 
        Next
 
 

However... if the software has child windows or multiple windows open it does not get the title of these "sub windows". An example is an application that has 2 windows open from the same exe. Is there anyway to grab all window titles of a process using this same logic?

[nukefusion]

I'm not sure quite how to go about this using .NET's process class. You can however do this using P/Invoke. Code similar to the following should work:

           private delegate bool EnumWindowsProc(IntPtr hWnd, int lParam);
 
        [DllImport("user32.dll", SetLastError=true)]
        private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
 
        [DllImport("USER32.DLL")]
        private static extern bool EnumWindows(EnumWindowsProc enumFunc, int lParam);
 
        [DllImport("USER32.DLL")]
        private static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
 
        [DllImport("USER32.DLL")]
        private static extern int GetWindowTextLength(IntPtr hWnd);
 
        [DllImport("USER32.DLL")]
        private static extern bool IsWindowVisible(IntPtr hWnd);
 
        [DllImport("USER32.DLL")]
        private static extern IntPtr GetShellWindow();
 
        public IDictionary<IntPtr, string> GetOpenWindowsFromPID(int processID)
        {
            IntPtr hShellWindow = GetShellWindow();
            Dictionary<IntPtr, string> dictWindows = new Dictionary<IntPtr, string>();
 
            EnumWindows(delegate(IntPtr hWnd, int lParam)
                        {
                            if (hWnd == hShellWindow) return true;
                            if (!IsWindowVisible(hWnd)) return true;
 
                            int length = GetWindowTextLength(hWnd);
                            if (length == 0) return true;
 
                            uint windowPid;
                            GetWindowThreadProcessId(hWnd, out windowPid);                            
                            if (windowPid != processID) return true;
 
                            StringBuilder stringBuilder = new StringBuilder(length);
                            GetWindowText(hWnd, stringBuilder, length + 1);
                            dictWindows.Add(hWnd, stringBuilder.ToString());
                            return true;
                        }, 0);
 
            return dictWindows;
        }

You can then use the Process class to get the Process ID of the application you are targeting and call the above code to get a list of windows associated it, something along the lines of:

            Process[] processes = Process.GetProcessesByName("MyApp");
            foreach (Process process in processes)
            {
                IDictionary<IntPtr, string> windows = this.GetOpenWindowsFromPID(process.Id);
                foreach (KeyValuePair<IntPtr, string> kvp in windows)
                {
                    // Do whatever you want here
                }
            }

If you want to target hidden windows also you can modify the code slightly.
Hope it helps!

[r035198x]

If your goal is simply to determine if a particular program is running or not, then why do you need to find all windows? I'd expect that finding at least one window is sufficient.
I will add also that not finding a window is not sufficient to determine that the program is not running.

[TomLasky]

Do you have this in VB.NET form? I've been trying to do something similar using GetdesktopWindo w Hwnd and then using HWNDNEXT to loop through them all, the problem is I cant get the desktopwindow hwnd for some reason.

I visited the pinvoke web site and found a lot of the findwindow api's and such, maybe im going about it the wrong way?

Also, in response to the last post, yes I do need to know the programs thats are running but I also need to know if those programs are running other windows inside of their app. Problem is .NET's getprocesses just gets the mainwindowtitle and doesnt also provide childwindows... in my personal opinion it's a huge let down on the part of .NET. Everyone is always informing me to try and not use Win32API's directly because it's unmanaged and sloppy but in this instance im forced to use it. Anyway, any help would be appreciated, I'm on my 9th hour of google searching for a simple thing I could do in VB6 in 5 minutes.

[Plater]

As pointed out, not finding the window doesn't mean the pogram is not running.
Shouldn't you be looking for a particular .exe or some other more discriminate property to see if it is running?

[TomLasky]

Here's what I'm doing:

I'm managing instant message windows or trying to anyway. I need to get all open windows for a specific program. I can find if a application is running, thats not the problem. The problem is finding all open windows for that app. As of right now I can only get the active top most window of that app and thats it, but theres 20 more windows from the same app that are not being found. I understand software can be hidden and just because an open window isn't there doesn;t mean it's not running, understood but it has no bearing on what im trying to accomplish.

Simply put... if you have 10 instant message windows open using AIM, I need to find the title text for all of those windows, not just the mainwindowtitle .

I've been messing around with old school enumwindows but its not working in .NET, most likely im declaring the wrong type. As of now I butchered the code so badly I'm starting from scratch. I liked the first answer posted, makes sense im lost with delegates and need help in the area of vb.net.

[Plater]

Ahh ok, you aren't so much interested in the running process, as what the process is running (all its windows)

Yeah I am afraid you are stuck using win32_api for that unfortunatly

[TomLasky]

I forgot to thank everyone for their help, I'm just burnt out pounding my head against the wall over this so I apologize for my lack of understanding. But sincerely, thank you for your time in helping me with this, it's much appreciated.

[TomLasky]

Plater, I was hoping it wouldn't be so! haha... oh well...

Any advice on proper logic to use to go about doing this?

I was trying to start from getting the desktop hwnd and then going hwndnext, I dont know... I'm brainless right now.

[nukefusion]

Hi Tom,

Sorry, VB.NET really isn't my strong point but still, I've had a go at translating the code sample for you. I hope you can get some use out of it.

Imports System.Runtime.InteropServices
Imports System.Text
 
Public Class Test
 
    <DllImport("USER32.DLL")> _
    Private Shared Function GetShellWindow() As IntPtr
    End Function
 
    <DllImport("USER32.DLL")> _
    Private Shared Function GetWindowText(ByVal hWnd As IntPtr, ByVal lpString As StringBuilder, ByVal nMaxCount As Integer) As Integer
    End Function
 
    <DllImport("USER32.DLL")> _
    Private Shared Function GetWindowTextLength(ByVal hWnd As IntPtr) As Integer
    End Function
 
    <DllImport("user32.dll", SetLastError:=True)> _
    Private Shared Function GetWindowThreadProcessId(ByVal hWnd As IntPtr, <Out()> ByRef lpdwProcessId As UInt32) As UInt32
    End Function
 
    <DllImport("USER32.DLL")> _
    Private Shared Function IsWindowVisible(ByVal hWnd As IntPtr) As Boolean
    End Function
 
    Private Delegate Function EnumWindowsProc(ByVal hWnd As IntPtr, ByVal lParam As Integer) As Boolean
 
    <DllImport("USER32.DLL")> _
    Private Shared Function EnumWindows(ByVal enumFunc As EnumWindowsProc, ByVal lParam As Integer) As Boolean
    End Function
 
    Private hShellWindow As IntPtr = GetShellWindow()
    Private dictWindows As New Dictionary(Of IntPtr, String)
    Private currentProcessID As Integer
 
 
    Public Function GetOpenWindowsFromPID(ByVal processID As Integer) As IDictionary(Of IntPtr, String)
        dictWindows.Clear()
        currentProcessID = processID
        EnumWindows(AddressOf enumWindowsInternal, 0)
        Return dictWindows
    End Function
 
    Private Function enumWindowsInternal(ByVal hWnd As IntPtr, ByVal lParam As Integer) As Boolean
        If (hWnd <> hShellWindow) Then
            Dim windowPid As UInt32
            If Not IsWindowVisible(hWnd) Then
                Return True
            End If
            Dim length As Integer = GetWindowTextLength(hWnd)
            If (length = 0) Then
                Return True
            End If
            GetWindowThreadProcessId(hWnd, windowPid)
            If (windowPid <> currentProcessID) Then
                Return True
            End If
            Dim stringBuilder As New StringBuilder(length)
            GetWindowText(hWnd, stringBuilder, (length + 1))
            dictWindows.Add(hWnd, stringBuilder.ToString)
        End If
        Return True
    End Function
End Class

You should be able to call it in a similar fashion, although I haven't tested this even though it does compile, i.e:

Dim processes As Process() = Process.GetProcessesByName("MyApp")
For Each process As Process In processes
    Dim windows As IDictionary(Of IntPtr, String) = GetOpenWindowsFromPID(process.Id)
    For Each kvp As KeyValuePair(Of IntPtr, String) In windows
                        ' Do whatever you want here 
    Next
Next