WndProc() Inside a Window Class

    
////////////////////////////////////////////////////////////////////////////////

// ATL/AUX -- COM/ATL Useful Helpers

// Copyright (c) by Andrew Nosenko (andien@geocities.com), 1997-99

// http://www.geocities.com/~andien/atlaux.htm

// Version: 1.10.0011


/*
	óðåçàííàÿ ââåðñèÿ
*/

#ifndef _AtlAux2_78310e22_e3e6_4f10_9af5_a4e485060097
#define _AtlAux2_78310e22_e3e6_4f10_9af5_a4e485060097

#if _MSC_VER > 1000 
#pragma once
#endif // _MSC_VER > 1000

////////////////////////////////////////////////////////////////////////////////
/* Win32 Callback thunking, the main idea was taken from ATL.

Thunks could be used to turn an object+method pair into a closure that could be
passed to Win32 API requiring a callback address. This is a clever idea of ATL
team, I've only tried to propagate it over a general case.
Thunks are very suitable and efficient way to avoid tiresome TLS/CritSecs/maps
(when providing apartment threading and reentrancy).

CAuxThunk<> is provided for __thiscall methods, CAuxStdThunk<> is for __stdcall.

Here is an example of how to set up Win32 hook the reentrant way, without a
use of global variable:

class CHook:
  public CAuxThunk<CHook>
{
public:
  CHook(): m_hhook(NULL)
  {
    InitThunk((TMFP)CBTHook, this);
  }

  LRESULT CBTHook(int nCode, WPARAM wParam, LPARAM lParam);
  BOOL Hook() {
    m_hook = SetWindowsHookEx(WH_CBT, (HOOKPROC)GetThunk(), NULL, GetCurrentThreadId());
    return (BOOL)m_hook;
  }

  HHOOK m_hhook;
...
};

LRESULT CHook::CBTHook(int nCode, WPARAM wParam, LPARAM lParam)
{
  if ( nCode == HCBT_CREATEWND ) {
    UnhookWindowsHookEx(m_hook);
    HWND hwnd = (HWND)wParam;
    // do whatever we want with HWND
    ...
  }
  return CallNextHookEx(m_hook, nCode, wParam, lParam);
}

Another example. I need to process an event in my IE4 simple object
(windowless) *asynchronously* and use SetTimer API for that.
Unfortunately, TIMERPROC doesn't take any context info.
Here is how it has been solved:

struct TIMEOUT: CAuxThunk<TIMEOUT> {
  UINT m_timerID;
  CONTEXT m_contex;

  TIMEOUT(CONTEXT& contex): m_contex(contex)
  {
    InitThunk((TMFP)TimerProc, this);
  }
  void TimerProc(HWND, UINT, UINT idEvent, DWORD dwTime);
  ...
};

void TIMEOUT::TimerProc(HWND, UINT, UINT idEvent, DWORD dwTime)
{
  KillTimer(NULL, m_timerID); // one-shot callback
  // do any processing task
  ...
  delete this;
}
HRESULT CSimpleObj::Post(CONTEXT& contex) {
  TIMEOUT* pTimeout = new TIMEOUT(context);
  pTimeout->m_timerID = ::SetTimer(NULL, 0, timeout, (TIMERPROC)pTimeout->GetThunk());
}
//////////////////////////////////////////////////////////////////////////////*/

  
class CMyWindow : public CAuxThunk<CMyWindow>
{
public:
    CMyWindow()
    {
         InitThunk((TMFB)MyWindowProc);
    }

    //  Notice its not static or different in anyway from 

    //  normal member function

    LRESULT MyWindowProc(HWND,UINT,WPARAM,LPARAM);

    BOOL Create()
    {
      ......

      WNDCLASS Class;
      ....
      Class.lpfnWndProc=(WNDPROC)GetThunk();
      ......
    }
}
    

    
/*
template <class T> class Thunk
{
	BYTE asm86[12];
public:
	typedef void (__stdcall T::*ThunkType)();

	void InitThunk(ThunkType method, const T *pthis)
	{
		union uPtr { BYTE *byte; DWORD *dword; ThunkType method; };
		
		uPtr pAsm86;
		pAsm86.byte = asm86;
		uPtr pFn;
		pFn.method = method;

		*pAsm86.byte++	= 0x58; //pop eax
		*pAsm86.byte++	= 0x68; //push pthis
		*pAsm86.dword++	= (DWORD)pthis;
		*pAsm86.byte++	= 0x50; //push eax
		*pAsm86.byte++	= 0xE9; //jmp method
		*pAsm86.dword++	= (DWORD)pFn.dword - (DWORD)(this+1);

		//This function is valid only on multiprocessor computers.
		//FlushInstructionCache(GetCurrentProcess(), this, sizeof(*this));
	}

	FARPROC GetThunk() const
	{
		return (FARPROC)this;
	}
};
class Window : private Thunk<Window>
{
	LRESULT CALLBACK WindowProc(HWND,UINT,WPARAM,LPARAM);
public:
	Window()
	{
		InitThunk((Thunk<Window>::ThunkType)WindowProc,this);
		WNDCLASSEX wc;
		wc.lpfnWndProc=(WNDPROC)GetThunk();	
	}	
};
//*/