https://blog.csdn.net/jiangqin115/article/details/78368767
The addition of the new window QQ automatic recognition function when the theme, the following can automatically draw the outline of the window according to the position of the mouse. Today someone asked this question at the forum, let's discuss implementation principle of this function.
We need to understand the basic principles of software screenshots, screenshots when in fact created a new full-screen window, and then draw the current desktop screenshot above, most of the screenshot of the software, including QQ are doing so. Get the mouse position according to lower the window, there are several similar API can be used (WindowFromPoint, ChildWindowFromPoint, ChildWindowFromPointEx, RealChildWindowFromPoint).
Here we focus on ChildWindowFromPointEx, because we know there is a full-screen window covering the top, through the window to get the mouse position, be sure to first take a screenshot of the full-screen window, so we need to filter out the window, but only ChildWindowFromPointEx this API there are window filtering.
HWND ChildWindowFromPointEx(
HWND hwndParent, POINT pt, UINT uFlags );
Parameters
hwndParent
[in] Handle to the parent window.
pt
[in] Specifies a POINT structure that defines the client coordinates (relative to hwndParent) of the point to be checked.
uFlags
[in] Specifies which child windows to skip. This parameter can be one or more of the following values.
CWP_ALL
Does not skip any child windows
CWP_SKIPINVISIBLE
Skips invisible child windows
CWP_SKIPDISABLED
Skips disabled child windows
CWP_SKIPTRANSPARENT
Skips transparent child windows
So we have reason to believe that QQ full-screen window with a WS_EX_LAYERED property, then QQ by calling ChildWindowFromPointEx (hWndDesktop, ptCursor, CWP_SKIPINVISIBLE | CWP_SKIPTRANSPARENT), so that you can filter out invisible and Layered window, and then call the API through recursion, you can get inside a child window.
To validate our guess, how you can build yourself a Layered Window, and then use the QQ screenshot, you can see that QQ is not recognized by the window.
In addition, we can start after the QQ screenshots, the Windows key to activate the taskbar, and then change the task bar to minimize or close a window included in the shot, and then continue screenshots will find QQ not identified. This also shows the real-time capture QQ to get through the lower window of ChildWindowFromPointEx. This could be considered a Bug QQ screenshots.
Many did not capture software these problems, I think they should be preserved and the hierarchical relationship Area of all windows on the desktop at the start of shots, with behind are then stored information to identify, so even behind the window below changes the recognition will not be affected.
In addition, some screenshot of the software can recognize smaller than the window size of elements, such as each Item on the Toolbar control, their use should be MSAA (Microsoft Active Accessibility), standard controls generally support the interface.
Some people are interested in seeing the code by enumerating ways to identify the window, here is my code:
class CSCWinFilter
{
public:
static BOOL IsFilterWindow(HWND hWnd)
{
_ASSERTE(hWnd != NULL);
DWORD dwProcessID = GetCurrentProcessId();
if(hWnd != NULL && IsWindow(hWnd))
{
DWORD dwWinProcessId(0);
GetWindowThreadProcessId(hWnd, &dwWinProcessId);
if(dwProcessID == dwWinProcessId)
{
return TRUE;
}
}
return FALSE;
}
static DWORD GetIncludeStyle()
{
return WS_VISIBLE;
}
static DWORD GetExcludeStyleEx()
{
return WS_EX_TRANSPARENT;
}
static BOOL IsTargetPopupWindow()
{
return FALSE;
}
};
class CSCWinInfo
{
public:
HWND m_hWnd;
CRect m_rtWin; //window rect
INT m_nLevel; // 1 - pop up window ; 2N - child window
};
//pop up win 1 (level 1).. first Z order
// child11 (level 2)
// child12 (level 2)
// chilld121 (level 3)
// chilld122 (level 3)
//
// child3 (level 2)
//pop up win2
// child21 (level 2)
// child21 (level 2)
// .
// .
//pop up winN . last Z order
template<typename CWinFilterTraits = CSCWinFilter>
class CSCWinSpy: public CHYSingleton<CSCWinSpy>
{
public:
BOOL SnapshotAllWinRect()
{
ClearData();
// cache current window Z order when call this function
EnumWindows(EnumWindowsSnapshotProc, 1);
return TRUE;
}
//get from current Z order of desktop
HWND GetHWNDByPoint(CPoint pt)
{
m_hWndTarget = NULL;
EnumWindows(EnumWindowsRealTimeProc, MAKELPARAM(pt.x, pt.y));
return m_hWndTarget;
}
CRect GetWinRectByPoint(CPoint ptHit, BOOL bGetInRealTime = FALSE)
{
CRect rtRect(0, 0, 0, 0);
if(bGetInRealTime) //get from current Z order
{
HWND hWndTarget = GetHWNDByPoint(ptHit);
if(hWndTarget != NULL )
{
GetWindowRect(hWndTarget, &rtRect);
}
}
else //get from snapshot cache
{
GetRectByPointFromSnapshot(ptHit, rtRect);
}
return rtRect;
}
protected:
static BOOL CALLBACK EnumWindowsRealTimeProc(HWND hwnd, LPARAM lParam)
{
if(!PtInWinRect(hwnd, CPoint(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)))) return TRUE;
if(ShouldWinBeFiltered(hwnd)) return TRUE;
m_hWndTarget = hwnd;
if(CWinFilterTraits::IsTargetPopupWindow()) return FALSE; //this is the target window, exit search
EnumChildWindows(hwnd, EnumChildRealTimeProc, lParam);
return FALSE;
}
static BOOL CALLBACK EnumChildRealTimeProc(HWND hwnd, LPARAM lParam)
{
if(!PtInWinRect(hwnd, CPoint(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)))) return TRUE;
if(ShouldWinBeFiltered(hwnd)) return TRUE;
m_hWndTarget = hwnd;
EnumChildWindows(hwnd, EnumChildRealTimeProc, lParam);
return FALSE;
}
protected:
static BOOL CALLBACK EnumWindowsSnapshotProc(HWND hwnd, LPARAM lParam)
{
INT nLevel = lParam;
if(ShouldWinBeFiltered(hwnd)) return TRUE;
SaveSnapshotWindow(hwnd, nLevel);
if(!CWinFilterTraits::IsTargetPopupWindow())
{
++nLevel;
EnumChildWindows(hwnd, EnumChildSnapshotProc, nLevel);
}
return TRUE;
}
static BOOL CALLBACK EnumChildSnapshotProc(HWND hwnd, LPARAM lParam)
{
INT nLevel = lParam;
if(ShouldWinBeFiltered(hwnd)) return TRUE;
SaveSnapshotWindow(hwnd, nLevel);
++nLevel;
EnumChildWindows(hwnd, EnumChildSnapshotProc, nLevel);
return TRUE;
}
protected:
static BOOL PtInWinRect(HWND hWnd, CPoint pt)
{
CRect rtWin(0, 0, 0, 0);
GetWindowRect(hWnd, &rtWin);
return PtInRect(&rtWin, pt);
}
static BOOL ShouldWinBeFiltered(HWND hWnd)
{
if(CWinFilterTraits::IsFilterWindow(hWnd)) return TRUE;
DWORD dwStyle = GetWindowLong(hWnd, GWL_STYLE);
DWORD dwStyleMust = CWinFilterTraits::GetIncludeStyle();
if((dwStyle & dwStyleMust) != dwStyleMust) return TRUE;
DWORD dwStyleEx = GetWindowLong(hWnd, GWL_EXSTYLE);
DWORD dwStyleMustNot = CWinFilterTraits::GetExcludeStyleEx();
if((dwStyleMustNot & dwStyleEx) != 0) return TRUE;
return FALSE;
}
//find the first window that level is biggest
static BOOL GetRectByPointFromSnapshot(CPoint ptHit, CRect& rtRet)
{
int nCount = m_arSnapshot.size();
_ASSERTE(nCount > 0);
CSCWinInfo* pInfo = NULL;
CSCWinInfo* pTarget = NULL;
for(int i=0; i<nCount; ++i)
{
pInfo = m_arSnapshot[i];
_ASSERTE(pInfo != NULL);
//target window is found
//and level is not increasing,
//that is checking its sibling or parent window, exit search
if(pTarget != NULL
&& pInfo->m_nLevel <= pTarget->m_nLevel)
{
break;
}
if(PtInRect(&pInfo->m_rtWin, ptHit))
{
if(pTarget == NULL)
{
pTarget = pInfo;
}
else
{
if( pInfo->m_nLevel > pTarget->m_nLevel)
{
pTarget = pInfo;
}
}
}
}
if(pTarget != NULL)
{
#ifdef _DEBUG
if(pTarget != NULL)
{
HWND hWnd = pTarget->m_hWnd;
TCHAR szText[128] = {0};
_sntprintf(szText, 127, _T("GetRectByPointFromSnapshot: pt(%d, %d), hWnd(%x)"),
ptHit.x, ptHit.y, (UINT)(pInfo->m_hWnd));
OutputDebugString(szText);
}
#endif
rtRet.CopyRect(&pTarget->m_rtWin);
return TRUE;
}
return FALSE;
}
static VOID SaveSnapshotWindow(HWND hWnd, INT nLevel)
{
_ASSERTE(hWnd != NULL && IsWindow(hWnd));
CRect rtWin(0, 0, 0, 0);
GetWindowRect(hWnd, &rtWin);
if(rtWin.IsRectEmpty()) return;
CSCWinInfo* pInfo = new CSCWinInfo;
if(pInfo == NULL) return;
pInfo->m_hWnd = hWnd;
pInfo->m_nLevel = nLevel;
pInfo->m_rtWin = rtWin;
m_arSnapshot.push_back(pInfo);
}
static VOID ClearData()
{
int nCount = m_arSnapshot.size();
for(int i=0; i<nCount; ++i)
{
delete m_arSnapshot[i];
}
m_arSnapshot.clear();
}
protected:
friend class CHYSingleton<CSCWinSpy>;
CSCWinSpy() { NULL; }
~CSCWinSpy() { ClearData(); }
static HWND m_hWndTarget;
static std::vector<CSCWinInfo*> m_arSnapshot;
};
template<typename T> HWND CSCWinSpy<T>::m_hWndTarget = NULL;
template<typename T> std::vector<CSCWinInfo*> CSCWinSpy<T>::m_arSnapshot;
Such use, saving all levels of desktop window when shots start:
CSCWinSpy<CSCWinFilter>::GetInstance()->SnapshotAllWinRect();
Then you can query this way the top of the window to a location:
CRect rtSelect = CSCWinSpy<CSCWinFilter>::GetInstance()->GetWinRectByPoint(pt, FALSE);
http://www.cppblog.com/weiym/archive/2012/05/06/173845.html