Getting pid and details for topmost window

Question

Does anyone know how to get the PID of the top active window and then how to get the properties of the window using the PID? I mean properties like process name, program name, etc.

I'm using Qt under Linux (Ubuntu 9.10).

Answer 1

The PID of a window owner is stored in the X property _NET_WM_PID. Note that this is only a de-facto standard.

You have to find the id of the window first, then you can query for the property. I don't know of any abstraction QT provides for this, so you will probably have to use xlib or xcb.

Play with the tool xprop for starters.

Answer 2

xlib's XGetInputFocus will tell you which window has focus, which is probably more interesting than which is topmost. Cf. Xfree86's XGetInputFocus manpage.

If it's really the topmost window, and not the window-with-focus you're after, well, I don't think there is a simple call to do that, because xlib doesn't seem to offer any way of querying the global stacking order, which determines

Once you have the right window id, xprop will list the pid under _NET_WM_PID_ - though not all windows have such a property...

Postscript Fixed false claim above. I was lying awake last night thinking about this question. Long time since I've thought about xlib...

To summarise:

1. X does not offer any reliable association between window ids and pids. The implementation must have such, but there is no portable way to get privileged access to internals. Cf. http://stackoverflow.com/questions/151407/how-to-get-an-x11-window-from-a-process-id

2. X does not seem to offer any way of asking which is the topmost window, or whether one window occludes another. Likewise with privileged access... Cf. http://stackoverflow.com/questions/1201179/how-to-identify-top-level-x11-windows-using-xlib

3. Commonly available window managers and Qt don't have privileged access to X

4. Without both a way of finding the topmost window, and a reliable association of the window id to the matching pid, we can't solve the question.

5. We can find which window has focus, and this is probably what we want. But again, without the wid -> pid map ...

So, sorry, it looks like it can't be done.

Answer 3

Install wmctrl (from the repositories). wmctrl -lp could be what you want. You can always take a look at the source if you need it from your program.

Answer 4

One of things about X is that it's network transparent. It's quite possible that the actual window being displayed at the top (which has focus) is running on a machine other than your own in which case, the process id of the process running inside the window will make no sense on your machine.

Can you elaborate a little on what you want to do? I think there are some missing details here. Ideally, you should work at the X level rather than at the machine specific one.

Answer 5

there is a command in linux call xprop which is a utility for displaying window properties in an X server. In linux xprop -root gives you the root windows properties and also other active programs. then you can get the ID of the active window using this command:

xprop -root | grep _NET_ACTIVE_WINDOW\(WINDOW\)

to get just the active window ID ( without "_NET_ACTIVE_WINDOW(WINDOW): window id # " in the beginning of the line ) use this command:

xprop -root | awk '/_NET_ACTIVE_WINDOW\(WINDOW\)/{print $NF}'

now you can save this command output in a user defined variable:

myid=xprop -root | awk '/_NET_ACTIVE_WINDOW\(WINDOW\)/{print $NF}'

xprop have an attribute call -id. This argument allows the user to select window id on the command line. We should look for _NET_WM_PID(CARDINAL) in output ... so we use this command:

xprop -id $myid | awk '/_NET_WM_PID\(CARDINAL\)/{print $NF}'

this gives you the topmost active window process ID.

to be more trickey and do all things in just 1 command ... :

 xprop -id $(xprop -root | awk '/_NET_ACTIVE_WINDOW\(WINDOW\)/{print $NF}') | awk '/_NET_WM_PID\(CARDINAL\)/{print $NF}'

Now I can run these commands via my C++ program ( in linux ) using popen function, grab stdout and print or save it. popen creates a pipe so we can read the output of the program we are invoking.

( you can also use '/proc' file system and get more detail of a PID ('/proc/*YOUR_PID*/status') )

#include <string>
#include <iostream>
#include <stdio.h>
using namespace std;

inline std::string exec(char* cmd) {
    FILE* pipe = popen(cmd, "r");
    if (!pipe) return "ERROR";
    char buffer[128];
    std::string result = "";
    while(!feof(pipe)) {
        if(fgets(buffer, 128, pipe) != NULL)
                result += buffer;
    }
    pclose(pipe);
    return result;
}

int main()
{
    //we uses \\ instead of \ ( \ is a escape character ) in this string
 cout << exec("xprop -id $(xprop -root | awk '/_NET_ACTIVE_WINDOW\\(WINDOW\\)/{print $NF}') | awk '/_NET_WM_PID\\(CARDINAL\\)/{print $NF}'").c_str(); 
 return 0;
}