下面是这个换肤Demo的snapshots:

Demo程序从此下载。

代码如下：
 1 #include "kcstcmnctrls.h"
 2 #include "kapp.h"
 3 #include "resource.h"
 4
 5 using namespace kwinui;
 6
 7 class KRndSliderDemoDlg : public KDialogBase<KRndSliderDemoDlg>{
 8 public:
 9     BEGIN_MSG_MAP
10         MSG_HANDLER(WM_INITDIALOG,OnInitDialog)
11         COMMAND_ID_HANDLER(IDOK,OnOK)
12         COMMAND_ID_HANDLER(IDCANCEL,OnOK)
13     END_MSG_MAP(KDialogBase<KRndSliderDemoDlg>)
14
15     enum{IDD=IDD_DLG_ROUND_SLIDER};
16     
17     LRESULT OnInitDialog(UINT uMsg,WPARAM wParam,LPARAM lParam,bool& bHandled){
18         m_rscSlider1.SubclassDlgItem(IDC_SLIDER1,*this);
19         m_rscSlider2.SubclassDlgItem(IDC_SLIDER2,*this);
20
21         m_rscSlider1.SetRange(-179, 180, FALSE);
22         m_rscSlider1.SetPos(42);
23         m_rscSlider1.SetZero(90);
24         m_rscSlider1.SetInverted();
25
26         m_rscSlider1.SetDialColor(RGB(255, 255, 0));
27         m_rscSlider1.SetKnobColor(RGB(0, 0, 255));
28
29         m_rscSlider2.SetRange(875, 1080, FALSE);
30         m_rscSlider2.SetPos(948);
31         m_rscSlider2.SetZero(180);
32         m_rscSlider2.SetRadioButtonStyle();
33
34
35         m_rscSlider2.SetFontName(_T("Comic Sans MS"));
36         m_rscSlider2.SetFontSize(14);
37         m_rscSlider2.SetFontItalic();
38         m_rscSlider2.SetTextColor(RGB(0, 0, 255));
39
40         CentralizeWindow();
41         return TRUE;
42     }
43     LRESULT OnOK(WORD wID,WORD wNotifyCode,HWND hWndCtrl,bool& bHandled){
44         EndDialog(wID);
45         return 0;
46     }
47 private:
48     KRoundSlider    m_rscSlider1,m_rscSlider2;
49 };
50
51 class KRndSliderDemo : public KWinApp<KRndSliderDemo>{
52 public:
53     bool InitInstance(){
54         KRndSliderDemoDlg dlg;
55         dlg.DoModal();
56         return false;
57     }
58 };
59
60 KRndSliderDemo theApp;

程序主要是使用KRoundSlider类来子类化(subclass)两个标准的滑动条控制(slider control),其实这个类接管了WM_PAINT,WM_ERASEBKGROUND等绘制消息,所以两个标准控制只不过是充当占位符(placehold)而已,换成其他的标准控制也是一样。
此程序编译需要用到kdc.cpp,kmisc.cpp和ktypes.cpp源文件。
再次推荐ResEdit，很好的资源编辑器。
Visual C++ 2008 Express sp1 win32 project默认设置静态链接Release版本生成的程序大小为108KB。
截图：
代码下载

下面来演示一下KWinUI中如何使工作线程拥有窗口，代码如下：
 1 #include "kwin.h"
 2 #include "kctrls.h"
 3 #include "kapp.h"
 4
 5 using namespace kwinui;
 6
 7 class KMainWindow : public KWindowBase<KMainWindow>{
 8 public:
 9     KMainWindow():KWindowBase<KMainWindow>(_T("MyClassName")){}
10     BEGIN_MSG_MAP
11         MSG_HANDLER(WM_CREATE,OnCreate)
12         COMMAND_ID_HANDLER(1000,OnExit)
13     END_MSG_MAP(KWindowBase<KMainWindow>)
14
15     LRESULT OnCreate(UINT uMsg,WPARAM wParam,LPARAM lParam,bool& bHandled){
16         RECT rect1={30,30,90,60};
17         m_btnExit.Create(*this,_T("exit"),WS_CHILD|WS_VISIBLE|WS_TABSTOP,rect1,1000);
18         return 0;
19     }
20     LRESULT OnExit(WORD wID,WORD wNotifyCode,HWND hWndCtrl,bool& bHandled){
21         m_nRetCode=wID;
22         SendMessage(WM_CLOSE);
23         return 0;
24     }
25 private:
26     int     m_nRetCode;
27     KButton m_btnExit;
28 };
29
30 class KWorkThread : public KThreadImpl<KWorkThread>{
31 public:
32     KWorkThread():KThreadImpl<KWorkThread>(CREATE_SUSPENDED){}
33     bool InitInstance(){
34         m_pMainWindow=new KMainWindow();
35         m_pMainWindow->CreateOverlappedWindow(_T("work thread’s main window"));
36         return true;
37     }
38     void ExitInstance(){
39         SAFE_DEL_PTR(m_pMainWindow);
40     }
41 public:
42     KMainWindow* m_pMainWindow;
43 };
44
45 class KThreadUIApp : public KWinApp<KThreadUIApp>{
46 public:
47     KThreadUIApp():m_pMainWindow(0),m_pWorkThread(0){}
48     bool InitInstance(){
49         m_pWorkThread=new KWorkThread();
50         m_pWorkThread->ResumeThread();
51
52         m_pMainWindow=new KMainWindow();
53         m_pMainWindow->CreateOverlappedWindow(_T("main thread’s main window"));
54
55         return true;
56     }
57     void ExitInstance(){
58         SAFE_DEL_PTR(m_pMainWindow);
59         SAFE_DEL_PTR(m_pWorkThread);
60     }
61     
62 private:
63     KMainWindow*    m_pMainWindow;
64     KWorkThread*    m_pWorkThread;
65 };

66
67 KThreadUIApp theApp;

我们可以很清楚的看到，工作线程拥有UI窗口的方式与主线程是完全一样的，不过主线程多了一项简单的工作，创建工作线程而已。

我们甚至可以让主线程提前结束，而由工作线程继续显示窗口来与用户交互，这就更可以证明这两种线程是完全一样的。

用Visual C++ 2008 Express win32 project默认设置静态链接Release版本生成的程序大小为57KB。
截图：
代码下载

预告：近期会推出KWinUI换肤框架的Demo，敬请期待…

1. 参数crKey是透明颜色,默认为0
2. 参数bAlpha是透明度，取值0~255,0为完全透明，255为完全不透明,默认为128
3. 参数dwFlags为透明模式，如果取值LWA_COLORKEY则使用第一个参数设置的透明颜色来使窗口透明，如果取值LWA_ALPHA则使用第二个参数设置的alpha值来透明化窗口,默认为LWA_ALPHA

这里使用了默认参数。
用Visual C++ 2008 Express win32 project默认设置静态链接Release版本生成的程序大小为54KB。
截图:
代码下载

启动ResEdit添加一个简单的dialog资源，ResEdit为你生成两个文件，一个是资源文件，一个包含资源ID的头文件resource.h。我这里简单的把这两个文件的内容贴出来。

resource.h
1 #ifndef IDC_STATIC
2 #define IDC_STATIC (-1)
3 #endif
4
5 #define IDD_DLG_MAIN                            100

dlgmain.rc
 1 // Generated by ResEdit 1.4.4.19
 2 // Copyright (C) 2006-2008
 3 // http://www.resedit.net
 4
 5 #include "resource.h"
 6 #include <windows.h>
 7 #include <commctrl.h>
 8 #include <richedit.h>
 9
10
11 //
12 // Dialog resources
13 //
14 IDD_DLG_MAIN DIALOG 0, 0, 186, 95
15 STYLE DS_3DLOOK | DS_CENTER | DS_MODALFRAME | DS_SHELLFONT | WS_VISIBLE | WS_BORDER | WS_CAPTION | WS_DLGFRAME | WS_POPUP | WS_SYSMENU
16 CAPTION "Dialog"
17 FONT 8, "Ms Shell Dlg 2"
18 {
19     DEFPUSHBUTTON   "OK", IDOK, 129, 7, 50, 14, BS_DEFPUSHBUTTON
20     PUSHBUTTON      "Cancel", IDCANCEL, 129, 24, 50, 14, BS_PUSHBUTTON
21 }

然后就是我们的KWinUI主程序了，内容如下：
 1 #include "resource.h"
 2 #include "kapp.h"
 3 #include "kwin.h"
 4
 5 using namespace kwinui;
 6
 7 class KDlgMain : public KDialogBase<KDlgMain>{
 8 public:
 9     typedef KDialogBase<KDlgMain> __base;
10     enum{IDD=IDD_DLG_MAIN};
11
12     BEGIN_MSG_MAP
13         COMMAND_ID_HANDLER(IDOK,OnOK)
14         COMMAND_ID_HANDLER(IDCANCEL,OnCancel)
15     END_MSG_MAP(__base)
16
17     LRESULT OnOK(WORD wID,WORD wNotifyCode,HWND hWndCtrl,bool& bHandled){
18         ShowMessage(_T("KWinUI dialog based program sample!"));
19         return TRUE;
20     }
21
22     LRESULT OnCancel(WORD wID,WORD wNotifyCode,HWND hWndCtrl,bool& bHandled){
23         EndDialog(wID);
24         ::PostQuitMessage(0);
25         return TRUE;
26     }
27 };
28
29 class KDlgApp : public KWinApp<KDlgApp>{
30 public:
31     bool InitInstance(){
32         m_pMainWindow=new KDlgMain();
33         m_pMainWindow->Create(NULL);
34         return true;
35     }
36 private:
37     KDlgMain* m_pMainWindow;
38 };
39
40 KDlgApp theApp;

当然，我这里创建的是一个无模式对话框，使用了KWinUI的消息循环，你也可以把第33、34行改为
m_pMainWindow->DoModal();
return false;
这样的话会创建一个模式对话框，使用对话框自己提供的消息循环。
使用模式对话框时，可以将程序的第24行注释掉，但是对于无模式对话框，此行代码必须存在才能正确的结束程序。

实际上KWinUI程序的风格和WTL是很相似的，有WTL开发经历的童鞋看到这段代码应该感觉比较亲切。
用Visual C++ 2008 Express win32 project默认设置静态链接Release版本生成的程序大小为47KB。
代码下载
截图：

首先是KWinUI的开发和测试环境。在开发KWinUI的最初是用的Visual C++ 2005 Express和windows platform sdk,sdk的版本记不清楚了。对于开发工具，我是有新的不用旧的。后来换到了Visual C++ 2008 Express,sdk更新到了windows sdk 6.0。为什么要用Express版本，自然是因为它是免费的，而且相当的好用，运行速度飞快。VC的编辑器我是不用的，我还是习惯用vim，所以其实主要用到的还是它的Debugger，编译、链接的话用命令行也是一样的方便。KWinUI还特别考虑到了C++ Builder系列的兼容性，因为我早年用过一段时间C++ Builder，相当不错的工具。不过我只在Turbo C++ Explore下面做过测试，除了它生成的程序体积比VC大一些以外，其他都还正常。甚至KWinUI可以与VCL混合编程，我试过。所以使用VC 2005/2008 Express加上最新的windows sdk或者Turbo C++ Explore以上版本的C++ Builder,来使用KWinUI应该都是没有问题的。

其次是关于界面设计。KWinUI是没有可视化界面设计器的，不过对于Dialog Based应用来说，这也不是很大的问题，我习惯用ResEdit来设计界面，也是很方便的，ResEdit是一个很不错的资源编辑器，现在完全支持UNICODE，使用很简单。后面会放出几个这样的samples。后面的samples会尽量带上截图，可以更直观的看到用KWinUI做出来的程序长啥样子:)，其实不过就是标准的windows程序界面。KWinUI的程序支持系统的视觉样式也是很简单的，增加个manifest资源就可以了，关于这个网上介绍的不少。我也基于KWinUI做了一个支持程序换肤的库，不过还不太成熟，有机会可以展示一下。

下面就是KWinUI的Hello World程序。

 1 #include "kwin.h"
 2 #include "kapp.h"
 3
 4 using namespace kwinui;
 5
 6 class KMainWindow : public KWindowBase<KMainWindow>{
 7 public:
 8     KMainWindow():KWindowBase<KMainWindow>(_T("MyClassName")){}
 9
10     BEGIN_MSG_MAP
11         MSG_HANDLER(WM_PAINT,OnPaint)
12     END_MSG_MAP(KWindowBase<KMainWindow>)
13
14     LRESULT OnPaint(UINT uMsg,WPARAM wParam,LPARAM lParam,bool& bHandled){
15         PAINTSTRUCT ps;
16         HDC hDC;
17
18         RECT rect;
19         ::GetClientRect(m_hWnd,&rect);
20         
21         hDC=::BeginPaint(m_hWnd,&ps);
22         ::SetBkMode(hDC,TRANSPARENT);
23         ::DrawText(hDC,_T("Hell World!"),-1,&rect,DT_SINGLELINE|DT_CENTER|DT_VCENTER);
24         ::EndPaint(m_hWnd,&ps);
25
26         return 0;
27     }
28 };
29
30 class KUIThreadApp : public KWinApp<KUIThreadApp>{
31 public:
32     bool InitInstance(){
33         m_pMainWindow=new KMainWindow();
34         m_pMainWindow->CreateOverlappedWindow(_T("Hello World!"));
35         m_pMainWindow->ShowWindow(m_nCmdShow);
36         m_pMainWindow->UpdateWindow();
37
38         return true;
39     }
40     void ExitInstance(){
41         SAFE_DEL_PTR(m_pMainWindow);
42     }
43     
44 private:
45     KMainWindow* m_pMainWindow;
46 };
47
48 KUIThreadApp theApp;

代码下载
用Visual C++ 2008 Express win32 project默认设置静态链接Release版本生成的程序大小为54KB。
截图：

比较各种GUI Framework的优劣是没有太多意义的，存在的东西都有它存在的合理性和适用的范围。从来没有能满足所有需求的东西，C++亦如是，虽然它是如此的强大。KWinUI来源自开发实践，是做一个项目过程中产生的。对于一个界面并不算复杂的小项目来说，那些重量级的framework太过沉重了,而每次用SDK来写界面，显然又过于繁琐了，所以有了KWinUI。KWinUI使用C++来包装windows SDK,并没有使用太复杂的技术，太复杂的我也不会:)，主要使用了thunk技术和C++模板的静多态特性，并且仔细考虑了线程安全，毕竟在这个多核的时代，如果不是线程安全的就显得不那么in。

跨平台不是KWinUI的诉求，现在不是、将来也不是，现在就有很多十分优秀的跨平台GUI开发框架，比如VCF,wxWidget,gtk+,QT等。KWinUI更像是一个自娱自乐的产物，只是觉得它可能对其他一些人也有用处，所有采用lgpl协议将它公布于众，如果能对其他人有些微的帮助，那么开放它的目的就达到了。采用lgpl的好处就是你可以放心的使用KWinUI,就是在商业程序中使用也没有问题。但是如果你对KWinUI做了更好的修改，最好公布一下修改的代码，以便给其他人以帮助。就算KWinUI真的没啥价值，这样发布应该也不会对别人造成什么伤害，权当娱乐一回吧，呵呵。

KWinUI的主要特性如下：
轻量、高效、资源占用少、线程安全、使用简单，差不多就这些了。

KWinUI因为使用了模板技术，所以就是一堆头文件和几个cpp文件，使用起来相当简单，后面我会继续发几个简单的sample来演示如何使用KWinUI。

如果非要有一个版本号的话，那么就定为 0.1.0吧，因为KWinUI实在是挺稚嫩的。

如果有人对KWinUI有兴趣，欢迎对它进行进一步的修改。

KWinUI的全部源程序从此下载，很小的，我保证你瞬间就能下载下来:)

我这里要讲的是窗口回调专用thunk，thunk的核心是调用栈动态修改技术。地球人都知道，windows的窗口回调函数是一个全局函数，类成员函数 是不可以作为窗口回调函数的，因为它有this指针，这给我们用C++来包装窗口带来不小的麻烦。你说什么？用一个全局函数或类的静态成员函数来做窗口回 调函数？这肯定没问题。但是这样带来的麻烦也许比你想象的要多，想想我们的GUI Framework不会只有一个类，而是一个类层级结构，会有许许多许多、形形色色的widget，每个都是一个窗口。对象与窗口之间的映射可能就是个不 小的问题，像MFC那样搞？太落伍了吧！用thunk就要简单的多。WTL用了thunk，但是不够彻底。
废话少说，先贴出thunk核心代码。

 20 /*
 21  *  thunk with DEP support
 22  *
 23  *  author:proguru
 24  *  July 9,2008
 25  */
 26 /*
 27  *  modify x64 thunk code according to the feedback from Loaden
 28  *  "http://topic.csdn.net/u/20090322/08/b6bf82ca-8ba2-452b-92f8-bb2adb05a1ef.html"
 29  *  maybe also "http://www.qpsoft.com/blog/x64-thunk-callback-conversion/"
 30  *  
 31  *  proguru
 32  *  June 04,2009
 33  */
 34
 35 #ifndef __KTHUNK_H__
 36 #define __KTHUNK_H__
 37 #include "windows.h"
 38  
 39 namespace kwinui{
 40
 41 //#define USE_THISCALL_CONVENTION   //turn it off for c++ builder compatibility
 42
 43 #ifdef USE_THISCALL_CONVENTION
 44     #define WNDPROC_THUNK_LENGTH    29  //For __thiscall calling convention ONLY,assign m_hWnd by thunk
 45     #define GENERAL_THUNK_LENGTH    10
 46     #define KCALLBACK                   //__thiscall is default
 47 #else
 48     #define WNDPROC_THUNK_LENGTH    22 //__stdcall calling convention ONLY,assign m_hWnd by thunk
 49     #define GENERAL_THUNK_LENGTH    16
 50     #define KCALLBACK __stdcall
 51 #endif
 52
 53 #define WNDPROC_THUNK_LENGTH_X64    28
 54 #define GENERAL_THUNK_LENGTH_X64    34
 55
 56 static HANDLE g_hHeapExecutable;
 57
 58 class KThunkBase{
 59 public:
 60     KThunkBase(SIZE_T size){
 61         if(!g_hHeapExecutable){       //first thunk,create the executable heap
 62             g_hHeapExecutable=::HeapCreate(HEAP_CREATE_ENABLE_EXECUTE,0,0);
 63             //if (!g_hHeapExecutable) abort
 64         }
 65         m_szMachineCode=(unsigned char*)::HeapAlloc(g_hHeapExecutable,HEAP_ZERO_MEMORY,size);
 66     }
 67     ~KThunkBase(){
 68         if(g_hHeapExecutable)
 69             ::HeapFree(g_hHeapExecutable,0,(void*)m_szMachineCode);
 70     }
 71     inline void* GetThunkedCodePtr(){return &m_szMachineCode[0];}
 72 protected:
 73     unsigned char* m_szMachineCode;
 74 };
 75
 76 class KWndProcThunk : public KThunkBase{
 77 public:
 78 #ifndef _WIN64
 79     KWndProcThunk():KThunkBase(WNDPROC_THUNK_LENGTH){}
 80 #else   //_WIN64
 81     KWndProcThunk():KThunkBase(WNDPROC_THUNK_LENGTH_X64){}
 82 #endif
 83
 84     void Init(INT_PTR pThis, INT_PTR ProcPtr){
 85 #ifndef _WIN64
 86         #pragma warning(disable: 4311)
 87         DWORD dwDistance =(DWORD)(ProcPtr) – (DWORD)(&m_szMachineCode[0]) – WNDPROC_THUNK_LENGTH;
 88         #pragma warning(default: 4311)
 89
 90     #ifdef USE_THISCALL_CONVENTION
 91         /*
 92         For __thiscall, the default calling convention used by Microsoft VC++, The thing needed is
 93         just set ECX with the value of ‘this pointer’
 94
 95         machine code                    assembly instruction        comment
 96         —————————     ————————-   ———-
 97         B9 ?? ?? ?? ??                  mov ecx, pThis              ;Load ecx with this pointer
 98         50                              PUSH EAX            
 99         8B 44 24 08                     MOV EAX, DWORD PTR[ESP+8]   ;EAX=hWnd
100         89 01                           MOV DWORD PTR [ECX], EAX    ;[pThis]=[ECX]=hWnd
101         8B 44 24 04                     mov eax,DWORD PTR [ESP+04H] ;eax=(return address)
102         89 44 24 08                     mov DWORD PTR [ESP+08h],eax ;hWnd=(return address)
103         58                              POP EAX        
104         83 C4 04                        add ESP,04h        
105                         
106         E9 ?? ?? ?? ??                  jmp ProcPtr                 ;Jump to target message handler
107         */
108         m_szMachineCode[0]                = 0xB9;
109         *((DWORD*)&m_szMachineCode[1] ) =(DWORD)pThis;
110         *((DWORD*)&m_szMachineCode[5] )   =0x24448B50;  
111         *((DWORD*)&m_szMachineCode[9] )   =0x8B018908;
112         *((DWORD*)&m_szMachineCode[13])   =0×89042444;
113         *((DWORD*)&m_szMachineCode[17])   =0×58082444;
114         *((DWORD*)&m_szMachineCode[21])   =0xE904C483;
115         *((DWORD*)&m_szMachineCode[25]) =dwDistance;  
116     #else  
117         /*
118          * 01/26/2008 modify
119         For __stdcall calling convention, replace ‘HWND’ with ‘this pointer’
120
121         Stack frame before inserting            Stack frame after inserting
122
123         :      …      :                       :       …      :
124         |—————|                       |—————-|
125         |     lParam    |                       |     lParam     |
126         |—————|                       |—————-|
127         |     wParam    |                       |     wParam     |
128         |—————|                       |—————-|
129         |     uMsg      |                       |     uMsg       |
130         |—————|                       |—————-|
131         |     hWnd      |                       | <this pointer> |
132         |—————|                       |—————-|
133         | (Return Addr) | <- ESP                | (Return Addr)  | <-ESP
134         |—————|                       |—————-|
135         :      …      :                       :       …      |
136
137         machine code        assembly instruction            comment
138         ——————- —————————-    ————–
139         51                  push ecx
140         B8 ?? ?? ?? ??      mov  eax,pThis                  ;eax=this;
141         8B 4C 24 08         mov  ecx,dword ptr [esp+08H]    ;ecx=hWnd;
142         89 08               mov  dword ptr [eax],ecx        ;[this]=hWnd,if has vftbl shound [this+4]=hWnd          
143         89 44 24 08         mov  dword ptr [esp+08H], eax   ;Overwite the ‘hWnd’ with ‘this pointer’
144         59                  pop  ecx
145         E9 ?? ?? ?? ??      jmp  ProcPtr                    ; Jump to target message handler
146         */
147
148         *((WORD  *) &m_szMachineCode[ 0]) = 0xB851;
149         *((DWORD *) &m_szMachineCode[ 2]) = (DWORD)pThis;
150         *((DWORD *) &m_szMachineCode[ 6]) = 0x08244C8B;
151         *((DWORD *) &m_szMachineCode[10]) = 0×44890889;
152         *((DWORD *) &m_szMachineCode[14]) = 0xE9590824;
153         *((DWORD *) &m_szMachineCode[18]) = (DWORD)dwDistance;
154     #endif //USE_THISCALL_CONVENTION
155 #else   //_WIN64
156         /* 
157         For x64 calling convention, RCX hold the ‘HWND’,copy the ‘HWND’ to Window object,
158         then insert ‘this pointer’ into RCX,so perfectly!!!    
159
160         Stack frame before modify               Stack frame after modify
161
162         :      …      :                       :       …      :
163         |—————|                       |—————-|
164         |               | <-R9(lParam)          |                | <-R9(lParam)
165         |—————|                       |—————-|
166         |               | <-R8(wParam)          |                | <-R8(wParam)
167         |—————|                       |—————-|
168         |               | <-RDX(msg)            |                | <-RDX(msg)
169         |—————|                       |—————-|
170         |               | <-RCX(hWnd)           |                | <-RCX(this)
171         |—————|                       |—————-|
172         | (Return Addr) | <-RSP                 | (Return Addr)  | <-RSP
173         |—————|                       |—————-|
174         :      …      :                       :   …  :
175
176         machine code            assembly instruction    comment
177         ——————-     ———————– —-
178         48B8 ????????????????   mov RAX,pThis
179         #4808                   mov qword ptr [RAX],RCX ;m_hWnd=[this]=RCX
180         488908                  mov qword ptr [RAX],RCX ;m_hWnd=[this]=RCX //feedback from Loaden
181         4889C1                  mov RCX,RAX             ;RCX=pThis (488BC8 ?)
182         48B8 ????????????????   mov RAX,ProcPtr
183         FFE0                    jmp RAX    
184         */
185         *((WORD   *)&m_szMachineCode[0] ) =0xB848;
186         *((INT_PTR*)&m_szMachineCode[2] ) =pThis;
187         //*((DWORD  *)&m_szMachineCode[10])   =0×89480848;
188         *((DWORD  *)&m_szMachineCode[10]) =0×48088948;
189         //*((DWORD  *)&m_szMachineCode[14])   =0x00B848C1;
190         *((DWORD  *)&m_szMachineCode[14]) =0xB848C189;
191         //*((INT_PTR*)&m_szMachineCode[17])   =ProcPtr;
192         *((INT_PTR*)&m_szMachineCode[18]) =ProcPtr;
193         //*((WORD   *)&m_szMachineCode[25])   =0xE0FF;
194         *((WORD   *)&m_szMachineCode[26]) =0xE0FF;
195 #endif
196     }
197 };

是不是有些头晕？且待我慢慢分解。
类成员函数有两种调用约定，MS VC++默认采用thiscall调用约定，而Borland C++默认采用stdcall调用约定。thiscall采用ECX寄存器来传递this指针，而stdcall则通过栈来传递this指针，this指 针是成员函数隐藏的第一个参数。而到了x64平台，则问题有了新的变化。为了充分利用寄存器，提高效率，函数的前四个参数默认用寄存器传递，分别是 RCX,RDX,R8和R9。对于成员函数，其this指针通过RCX传递。x64 thunk代码我并未测试过，因为一直未使用x64平台，不过应该不会有太大问题。

在这里，我只分析x86平台上使用stdcall调用习惯的thunk代码。因为这段代码将窗口回调函数调用栈上的HWND直接修改this指针，所以有两个问题需要提前了解一下。
第一、我将回调函数的signature修改为如下形式：
LRESULT KCALLBACK KWndProc(UINT uMsg, WPARAM wParam, LPARAM lParam) ;
请注意这是个成员函数，而且没有HWND hWnd这个参数。
第二、窗口类的第一个数据成员必须是窗口句柄变量，我的是HWND m_hWnd.至于为什么要这样，后面会有提及。
现在请看代码第85行开始的图形，前一个是修改前windows调用我们提供的回调函数的栈结构，后一个则是为了适应我们的需求修改过后的调用栈。首先， 我们的回调函数需要一个this指针，而且要放到栈上第一个参数的位置上，这是通过第46行的thunk初始化函数Init传递进来的。其次我们的窗口对象必须要得到自己所对应的窗口句柄，不然一切都是空谈。

那么我们可以用thunk来修改调用栈。首先用初始栈上的第一个参数，也就是实际的窗口句柄，传递给窗口对象。如何传递呢？因为m_hWnd成员是对象的 第一个数据成员，那么很简单，如果没有虚函数的存在，那么这个m_hWnd就静静地待在对象的最开始处，就是this指针所指向的位置。如果有虚函数的存 在，那么事情也不是太复杂，对象的起始处现在是VPTR,m_hWnd紧随其后，代码略作调整即可。其次用this指针覆盖栈上的第一个参数，也就是窗口 句柄HWND。下面是逐条注释的汇编格式指令：
1 push ecx                        ;保护ecx，后面会用到
2 mov  eax,pThis                  ;传送this指针到eax. eax=this;
3 mov  ecx,dword ptr [esp+08H]    ;把调用栈上的第一个参数送ecx. ecx=hWnd
4 mov  dword ptr [eax],ecx        ;把窗口句柄赋予窗口对象数据成员m_hWnd.
5                                 ;[this]=hWnd,if has vftbl shound [this+4]=hWnd            
6 mov  dword ptr [esp+08H], eax   ;用this指针覆盖调用栈上的第一个参数即窗口句柄
7                                 ;Overwite the ‘hWnd’ with ‘this pointer’
8 pop  ecx                        ;弹出先前ecx
9 jmp  ProcPtr                    ;跳转到消息处理函数.Jump to target message handler

这样就把窗口(句柄)和窗口对象完美的绑定到一起，不需要一个对应查找表，不使用任何全局或静态的数据，满足thread safe。

至于汇编格式指令翻译到机器码的问题，下载intel的指令手册，查查表就可以了。
下面的代码展示了thunk的使用(删除了不相干的代码)：
 1 template <typename T,typename TBase=KWindow>
 2 class KWindowRoot : public TBase{
 3 public:
 4     KWindowRoot():TBase(){
 5         T* pT=static_cast<T*>(this);
 6         m_thunk.Init((INT_PTR)pT, pT->GetMessageProcPtr());
 7     }
 8  
 9     INT_PTR GetMessageProcPtr(){
10         typedef LRESULT (KCALLBACK T::*KWndProc_t)(UINT,WPARAM,LPARAM);
11         
12         union{
13             KWndProc_t     wndproc;
14             INT_PTR        dwProcAddr;
15         }u;
16         u.wndproc=&T::KWndProc;
17         return u.dwProcAddr;
18     }
19  
20     LRESULT KCALLBACK KWndProc(UINT uMsg, WPARAM wParam, LPARAM lParam){
21         T* pT=static_cast<T*>(this);
22         return pT->ProcessWindowMessage(uMsg,wParam,lParam);
23     }
24  
25 protected:
26     KWndProcThunk   m_thunk;
27     inline INT_PTR GetThunkedProcPtr(){return (INT_PTR)m_thunk.GetThunkedCodePtr();}
28 };

在基类KWindow中HWND m_hWnd是其第一个数据成员。因为使用了模板的静态多态特性，故对象没有VPTR指针。
到了这里事情还没有结束。既然使用thunk就不得不面对DEP。DEP会阻止没有执行权限的内存执行代码。如果我们的thunk分配在栈上或new出来的堆上，则会被DEP阻止，程序执行失败。因此可以申请一个具有执行权限的堆来解决这个问题：
1 KThunkBase(SIZE_T size){
2     if(!g_hHeapExecutable){        //first thunk,create the executable heap
3         g_hHeapExecutable=::HeapCreate(HEAP_CREATE_ENABLE_EXECUTE,0,0);
4         //if (!g_hHeapExecutable) abort
5     }
6     m_szMachineCode=(unsigned char*)::HeapAlloc(g_hHeapExecutable,HEAP_ZERO_MEMORY,size);
7 }

总的来讲thunk的空间和时间开销都是足够小的，甚至可以忽略不计。但是却带来了极大的便利。
thunk只是开了一个头。

PS:原文早先发表于cppblog。根据 Loaden的反馈做了关于x64的修订。