َA Curiosity question on ATL CWindowImpl class

Question

Hi

This code is part of "atlwin.h" file for CWindowImplBaseT class. My question is in WindowProc static member How convert window handle to the corresponding window class object? how this possible? Because to converting we need a table with two column one for Window Handles and one for Object pointers then search it by handle to find corresponding object pointer. But in this code directly convert window handle to object (first line body code)!!!

CWindowImplBaseT< TBase, TWinTraits > pThis = (CWindowImplBaseT< TBase, TWinTraits >)hWnd;**

Thanks

template <class TBase, class TWinTraits>
LRESULT CALLBACK CWindowImplBaseT< TBase, TWinTraits >::WindowProc(
	_In_ HWND hWnd,
	_In_ UINT uMsg,
	_In_ WPARAM wParam,
	_In_ LPARAM lParam)
{
	CWindowImplBaseT< TBase, TWinTraits >* pThis = (CWindowImplBaseT< TBase, TWinTraits >*)hWnd;
	// set a ptr to this message and save the old value
	_ATL_MSG msg(pThis->m_hWnd, uMsg, wParam, lParam);
	const _ATL_MSG* pOldMsg = pThis->m_pCurrentMsg;
	pThis->m_pCurrentMsg = &msg;
	// pass to the message map to process
	LRESULT lRes = 0;
	BOOL bRet = pThis->ProcessWindowMessage(pThis->m_hWnd, uMsg, wParam, lParam, lRes, 0);
	// restore saved value for the current message
	ATLASSERT(pThis->m_pCurrentMsg == &msg);

	// do the default processing if message was not handled
	if(!bRet)
	{
		if(uMsg != WM_NCDESTROY)
			lRes = pThis->DefWindowProc(uMsg, wParam, lParam);
		else
		{
			// unsubclass, if needed
			LONG_PTR pfnWndProc = ::GetWindowLongPtr(pThis->m_hWnd, GWLP_WNDPROC);
			lRes = pThis->DefWindowProc(uMsg, wParam, lParam);
			if(pThis->m_pfnSuperWindowProc != ::DefWindowProc && ::GetWindowLongPtr(pThis->m_hWnd, GWLP_WNDPROC) == pfnWndProc)
				::SetWindowLongPtr(pThis->m_hWnd, GWLP_WNDPROC, (LONG_PTR)pThis->m_pfnSuperWindowProc);
			// mark window as destroyed
			pThis->m_dwState |= CWindowImplRoot<TBase>::WINSTATE_DESTROYED;
		}
	}
	if((pThis->m_dwState & CWindowImplRoot<TBase>::WINSTATE_DESTROYED) && pOldMsg== NULL)
	{
		// clear out window handle
		HWND hWndThis = pThis->m_hWnd;
		pThis->m_hWnd = NULL;
		pThis->m_dwState &= ~CWindowImplRoot<TBase>::WINSTATE_DESTROYED;
		// clean up after window is destroyed
		pThis->m_pCurrentMsg = pOldMsg;
		pThis->OnFinalMessage(hWndThis);
	}else {
		pThis->m_pCurrentMsg = pOldMsg;
	}
	return lRes;
}

Answer 1

A static function like WindowProc(HWND, MSG, WPARAM, LPARAM) is suitable for processing the messages that are remitted to a window or control.

In my opinion, to associate an existing ATL C++ object with this messaging, it was decided to create intermediate short functions (having the same signature) at run-time, which receive the calls from Windows, and then redirect these calls to ATL functions, adding the missing ATL object. These things are called “thunks”.

For unknown reasons, it was chosen to pass the ATL objects via the HWND parameter. (The duplicate value of HWND is available in the m_hWnd member of the object, therefore it is not lost). See the ‘struct _stdcallthunk’ in ATL files for specific instructions generated for different microprocessors. One of the document (https://learn.microsoft.com/en-us/windows/win32/api/atlthunk/nf-atlthunk-atlthunk_initdata) mentions that “An ATL thunk has a signature of WNDPROC”.

Therefore, the Windows calls the thunk, which then call the ATL function, replacing the first parameter with an object. Then the target function reinterprets the first parameter as an object.