c++ - 检查我的 QMainWindow 当前是否在 Qt 中可见

Question

我想知道我QMainWindow的当前是否可见并且没有被另一个应用程序的另一个窗口重叠。

我需要在 Windows、Linux 和 Mac 上实现这一点。

Answer 1

不久前我写了一个小库，用于读取前台或最顶层窗口信息，主要是窗口标题，跨 Windows、Mac OS X 和 Linux。你可以在这里找到源代码： https ://github.com/pcmantinker/Qt-Window-Title-Reader

我在 Windows 上使用原生 Windows API，在 Linux 上使用 X11 库，在 Mac OS X 上使用 Cocoa。

以下是如何使用 Objective-C++ 在 Mac OS X 中获取活动窗口的小示例：
Mac.h

/*
  Mac/Cocoa specific code for obtaining information about the frontmost window
*/

#ifndef MAC_H
#define MAC_H
#include <QtCore>
#include "windowinfo.h"

class Mac {
public:
    Mac();
    QList<WindowInfo> getActiveWindows();
};

#endif // MAC_H

麦克.mm

/*
  Mac/Cocoa specific code for obtaining information about the frontmost window
*/

#include "mac.h"
#include "Cocoa/Cocoa.h"

Mac::Mac()
{

}

QList<WindowInfo> Mac::getActiveWindows()
{
    QList<WindowInfo> windowTitles;

    // get frontmost process for currently active application
    ProcessSerialNumber psn = { 0L, 0L };
    OSStatus err = GetFrontProcess(&psn);

    CFStringRef processName = NULL;
    err = CopyProcessName(&psn, &processName);

    NSString *pname = (NSString *)processName;

    // loop through all application windows
    CFArrayRef windowList = CGWindowListCopyWindowInfo(kCGWindowListOptionOnScreenOnly | kCGWindowListExcludeDesktopElements, kCGNullWindowID);
    for (NSMutableDictionary* entry in (NSArray*)windowList)
    {
        NSString* ownerName = [entry objectForKey:(id)kCGWindowOwnerName];
        NSString *name = [entry objectForKey:@"kCGWindowName" ];
        NSInteger ownerPID = [[entry objectForKey:(id)kCGWindowOwnerPID] integerValue];
        NSInteger layer = [[entry objectForKey:@"kCGWindowLayer"] integerValue];
        if(layer == 0)
        {
            if([ownerName isEqualToString:pname])
            {
                NSRange range;
                range.location = 0;
                range.length = [ownerName length];

                unichar *chars = new unichar[range.length];
                [ownerName getCharacters:chars range:range];
                QString owner = QString::fromUtf16(chars, range.length);

                range.length = [name length];

                chars = new unichar[range.length];
                [name getCharacters:chars range:range];
                QString windowTitle = QString::fromUtf16(chars, range.length);
                delete[] chars;

                long pid = (long)ownerPID;

                WindowInfo wi;
                wi.setProcessName(owner);
                wi.setWindowTitle(windowTitle);
                wi.setPID(pid);
                windowTitles.append(wi);
            }
        }
    }
    CFRelease(windowList);
    CFRelease(processName);

    return windowTitles;
}

请注意，在 Cocoa 中，没有直接获取最顶层窗口的方法。你会得到一组窗口并循环遍历它们以找到你想要的窗口。
这是 Windows API 的代码：
win.h

/*
  Windows API specific code for obtaining information about the frontmost window
*/

#ifndef WIN_H
#define WIN_H
#include <QtCore>
#include "qt_windows.h"
#include "psapi.h"
#include "windowinfo.h"

class win : public QObject
{
    Q_OBJECT

public:
    win();
    QList<WindowInfo> getActiveWindows();

private:
    TCHAR buf[255];
};

#endif // WIN_H

赢.cpp

#include "win.h"

win::win()
{
}

QList<WindowInfo> win::getActiveWindows()
{
    QList<WindowInfo> windowTitles;
    HWND foregroundWindow = GetForegroundWindow();
    DWORD* processID = new DWORD;
    GetWindowText(foregroundWindow, buf, 255);
    GetWindowThreadProcessId(foregroundWindow, processID);
    DWORD p = *processID;
    HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION |
                                  PROCESS_VM_READ,
                                  FALSE, p);
    TCHAR szProcessName[MAX_PATH];

    if (NULL != hProcess )
    {
        HMODULE hMod;
        DWORD cbNeeded;

        if ( EnumProcessModules( hProcess, &hMod, sizeof(hMod),
                                 &cbNeeded) )
        {
            GetModuleBaseName( hProcess, hMod, szProcessName,
                               sizeof(szProcessName)/sizeof(TCHAR) );
        }
    }
    CloseHandle(hProcess);
    long pid = (long)p;
    QString windowTitle, processName;
#ifdef UNICODE
    windowTitle = QString::fromUtf16((ushort*)buf);
    processName = QString::fromUtf16((ushort*)szProcessName);
#else
    windowTitle = QString::fromLocal8Bit(buf);
    processName = QString::fromLocal8Bit(szProcessName);
#endif

    WindowInfo wi;
    wi.setPID(pid);
    wi.setWindowTitle(windowTitle);
    wi.setProcessName(processName);
    windowTitles.append(wi);
    return windowTitles;
}

这是 Linux/X11 的代码：
linux_x11.h

/*
  Linux/X11 specific code for obtaining information about the frontmost window
*/

#ifndef LINUX_X11_H
#define LINUX_X11_H

#include <QtCore>
#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include "windowinfo.h"

class linux_x11
{
public:
    linux_x11();
    QList<WindowInfo> getActiveWindows();

private:
    Window* active(Display *disp, unsigned long *len);
    char *name (Display *disp, Window win);
    int *pid(Display *disp, Window win);
    QString processName(long pid);
};

#endif // LINUX_X11_H

linux_x11.cpp

/*
  Linux/X11 specific code for obtaining information about the frontmost window
*/

#include "linux_x11.h"
#include <sstream>
#include <stdlib.h>
#include <stdio.h>

linux_x11::linux_x11()
{
}

/**
  * Returns the window name for a specific window on a display
***/
char *linux_x11::name (Display *disp, Window win) {
    Atom prop = XInternAtom(disp,"WM_NAME",False), type;
    int form;
    unsigned long remain, len;
    unsigned char *list;

    if (XGetWindowProperty(disp,win,prop,0,1024,False,AnyPropertyType, &type,&form,&len,&remain,&list) != Success)
        return NULL;

    return (char*)list;
}

/**
  * Returns the pid for a specific window on a display
***/
int* linux_x11::pid(Display *disp, Window win) {
    Atom prop = XInternAtom(disp,"_NET_WM_PID",False), type;
    int form;
    unsigned long remain, len;
    unsigned char *list;

    if (XGetWindowProperty(disp,win,prop,0,1024,False,AnyPropertyType, &type,&form,&len,&remain,&list) != Success)
        return NULL;

    return (int*)list;
}

/**
  * Returns the active window on a specific display
***/
Window * linux_x11::active (Display *disp, unsigned long *len) {
    Atom prop = XInternAtom(disp,"_NET_ACTIVE_WINDOW",False), type;
    int form;
    unsigned long remain;
    unsigned char *list;

    if (XGetWindowProperty(disp,XDefaultRootWindow(disp),prop,0,1024,False,XA_WINDOW, &type,&form,len,&remain,&list) != Success)
        return NULL;

    return (Window*)list;
}

/**
  * Returns process name from pid (processes output from /proc/<pid>/status)
***/
QString linux_x11::processName(long pid)
{
    // construct command string
    QString command = "cat /proc/" + QString("%1").arg(pid) + "/status";
    // capture output in a FILE pointer returned from popen
    FILE * output = popen(command.toStdString().c_str(), "r");
    // initialize a buffer for storing the first line of the output
    char buffer[1024];
    // put the contents of the buffer into a QString
    QString line = QString::fromUtf8(fgets(buffer, sizeof(buffer), output));
    // close the process pipe
    pclose(output);
    // take right substring of line returned to get process name
    return line.right(line.length() - 6).replace("\n", "");
}

QList<WindowInfo> linux_x11::getActiveWindows()
{
    QList<WindowInfo> windowTitles;
    unsigned long len;
    Display *disp = XOpenDisplay(NULL);
    Window *list;
    char *n;
    int* p;

    list = (Window*)active(disp,&len);
    if((int)len > 0)
    {
        for (int i=0;i<(int)len;i++) {
            n = name(disp,list[i]);
            p = pid(disp, list[i]);
            long p_id = 0;
            QString pName;
            QString windowTitle;

            if(p!=NULL)
            {
                p_id = *p; // dereference pointer for obtaining pid
                pName = processName(p_id);
            }

            if(n!=NULL)
                windowTitle = QString::fromUtf8(n);

            WindowInfo wi;
            wi.setWindowTitle(windowTitle);
            wi.setProcessName(pName);
            wi.setPID(p_id);
            windowTitles.append(wi);
            delete n;
            delete p;
        }
    }
    delete list;
    XCloseDisplay (disp);
    return windowTitles;
}

X11 代码可能会变得非常丑陋且难以理解，但这应该可以帮助您入门。自从我直接处理 X11 以来已经有一段时间了，所以我现在不能准确地告诉你每个辅助方法的作用。

我抽象了代码，使得每个平台特定的代码片段都具有相同的方法签名。然后我检查它是否在 Mac OS X、Windows 或 Linux 上编译并实例化正确的类。以下是它们是如何联系在一起的：

#include "windowtitlereader.h"

WindowTitleReader::WindowTitleReader()
{
    qDebug() << "WindowTitleReader::WindowTitleReader()";
    // refresh window reading every 10ms
    timer = new QTimer(this);
    timer->setInterval(10);
    timer->start();
    connect(timer, SIGNAL(timeout()), this, SLOT(getWindowTitle()));
}

WindowTitleReader::~WindowTitleReader()
{
    delete timer;
    delete m_pid;
    delete m_processName;
}
void WindowTitleReader::getWindowTitle()
{
    qDebug() << "WindowTitleReader::getWindowTitle()";
#ifdef Q_WS_WIN
    win w;
    m_activeWindows = w.getActiveWindows();
#endif

#ifdef Q_WS_MACX
    Mac m;
    m_activeWindows = m.getActiveWindows();
#endif

#ifdef Q_WS_X11
    linux_x11 l;
    m_activeWindows = l.getActiveWindows();
#endif
    for(int i = 0; i < m_activeWindows.count(); i++)
        qDebug() << "PID: " << m_activeWindows[i].getPID() << " Process Name: " << m_activeWindows[i].getProcessName() << " Window Title: " << m_activeWindows[i].getWindowTitle();
}

如果需要，您可以将刷新率更改为较慢的刷新率，但我每 10 毫秒运行一次更新，以便在窗口聚焦时获得近乎实时的更新。

我写这个库主要是为了阅读网络浏览器和视频游戏的窗口标题，这样我就可以估计人们在他们的电脑上玩某些游戏的时间。我将其作为我正在构建的游戏指标应用程序的一部分编写。