wxWidgets学习笔记（3）wxWidgets程序生死因果

     本文将分析wxWidgets应用程序如何开始执行、如何结束，如何创建主窗口，程序如何推动等问题。

    1 三个不同版本的 Hello World

    1－1  Hello World （Win32 SDK版）
    先看一下Win32 SDK简单程序，著名的Hello World。本程序由Code::Block在XP下通过向导生成，程序运行结果如图所示。
   

1. #include 
5. /*  Declare Windows procedure  */
7. LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
11. /*  Make the class name into a global variable  */
13. char szClassName[ ] = "CodeBlocksWindowsApp";
18. int WINAPI WinMain (HINSTANCE hThisInstance,                 // 1 程序入口 WinMain(...)
20.                      HINSTANCE hPrevInstance,
22.                      LPSTR lpszArgument,
24.                      int nCmdShow)
26. {
28.     HWND hwnd;               /* This is the handle for our window */
30.     MSG messages;            /* Here messages to the application are saved */
32.     WNDCLASSEX wincl;        /* Data structure for the windowclass */
36.     /* The Window structure */
38.     wincl.hInstance = hThisInstance;
40.     wincl.lpszClassName = szClassName;
42.     wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
44.     wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
46.     wincl.cbSize = sizeof (WNDCLASSEX);
50.     /* Use default icon and mouse-pointer */
52.     wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
54.     wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
56.     wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
58.     wincl.lpszMenuName = NULL;                 /* No menu */
60.     wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
62.     wincl.cbWndExtra = 0;                      /* structure or the window instance */
64.     /* Use Windows's default colour as the background of the window */
66.     wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
70.     /* Register the window class, and if it fails quit the program */
72.     if (!RegisterClassEx (&wincl))                                   // 2 注册窗口
74.         return 0;
78.     /* The class is registered, let's create the program*/
80.     hwnd = CreateWindowEx (
82.            0,                   /* Extended possibilites for variation */
84.            szClassName,         /* Classname */
86.            "Hello World!",       /* Title Text */
88.            WS_OVERLAPPEDWINDOW, /* default window */
90.            CW_USEDEFAULT,       /* Windows decides the position */
92.            CW_USEDEFAULT,       /* where the window ends up on the screen */
94.            544,                 /* The programs width */
96.            375,                 /* and height in pixels */
98.            HWND_DESKTOP,        /* The window is a child-window to desktop */
100.            NULL,                /* No menu */
102.            hThisInstance,       /* Program Instance handler */
104.            NULL                 /* No Window Creation data */
106.            );
110.     /* Make the window visible on the screen */
112.     ShowWindow (hwnd, nCmdShow);                  // 3 生成窗口并显示窗口
116.     /* Run the message loop. It will run until GetMessage() returns 0 */
118.     while (GetMessage (&messages, NULL, 0, 0))    // 4 消息循环，响应用户命令
120.     {
122.         /* Translate virtual-key messages into character messages */
124.         TranslateMessage(&messages);
126.         /* Send message to WindowProcedure */
128.         DispatchMessage(&messages);
130.     }
134.     /* The program return-value is 0 - The value that PostQuitMessage() gave */
136.     return messages.wParam;
138. }
143.                                                                     // 5 窗口处理过程
145. /*  This function is called by the Windows function DispatchMessage()  */
149. LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
151. {
153.     switch (message)                  /* handle the messages */
155.     {
157.         case WM_DESTROY:
159.             PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
161.             break;
163.         default:                      /* for messages that we don't deal with */
165.             return DefWindowProc (hwnd, message, wParam, lParam);
167.     }
171.     return 0;
173. }

    可以看出，Win32 SDK程序
    1） 从WinMain(...)开始执行；
    2） 通过RegisterClassEx(...)注册窗口类；
    3）通过CreateWindowEx(...)创建主窗口，并通过ShowWindow(...)显示窗口；
    4）通过 while (GetMessage (&messages, NULL, 0, 0))     消息循环，等待响应用户命令；
    5) 窗口处理过程为WindowProcedure(...)，在注册窗口的时候绑定。

    1－2 Hello World （GTK＋ 版）
    再看一下GTK＋ 简单程序，也是著名的Hello World。本程序由Code::Block在Ubuntu下通过向导生成，程序运行结果如图所示。

1. #include 
2. #include 
3.                                                    //5 消息处理函数，通过g_signal_connect与窗口、控件绑定
4. static void helloWorld (GtkWidget *wid, GtkWidget *win)
5. {
6.   GtkWidget *dialog = NULL;
8.   dialog = gtk_message_dialog_new (GTK_WINDOW (win), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, "Hello World!");
9.   gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
10.   gtk_dialog_run (GTK_DIALOG (dialog));
11.   gtk_widget_destroy (dialog);
12. }
14. int main (int argc, char *argv[])     // 1 程序入口 main(...)
15. {
16.   GtkWidget *button = NULL;
17.   GtkWidget *win = NULL;
18.   GtkWidget *vbox = NULL;
20.   /* Initialize GTK+ */                         // 2 初始化GTK＋
21.   g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, (GLogFunc) gtk_false, NULL);
22.   gtk_init (&argc, &argv);
23.   g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, g_log_default_handler, NULL);
25.   /* Create the main window */        // 3 生成主窗口以及窗口内的控件，并通过 g_signal_connect绑定消息处理函数。
26.   win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
27.   gtk_container_set_border_width (GTK_CONTAINER (win), 8);
28.   gtk_window_set_title (GTK_WINDOW (win), "Hello World");
29.   gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_CENTER);
30.   gtk_widget_realize (win);
31.   g_signal_connect (win, "destroy", gtk_main_quit, NULL);
33.   /* Create a vertical box with buttons */
34.   vbox = gtk_vbox_new (TRUE, 6);
35.   gtk_container_add (GTK_CONTAINER (win), vbox);
37.   button = gtk_button_new_from_stock (GTK_STOCK_DIALOG_INFO);
38.   g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (helloWorld), (gpointer) win);
39.   gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
41.   button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
42.   g_signal_connect (button, "clicked", gtk_main_quit, NULL);
43.   gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
45.   /* Enter the main loop */        //4 进入消息循环，响应用户命令。
46.   gtk_widget_show_all (win);
47.   gtk_main ();
48.   return 0;
49. }

    与Win32 SDK程序类似，
    1）从main(...)作为程序入口，开始执行；
    2）gtk_init(...)初始化GTK＋；
    3）gtk_window_new(...)生成主窗口；
    4)   gtk_main ()  进入消息循环，响应用户命令。

    1－3 Hello World（wxWidgets版）
    最后看一下wxWidgets应用程序，源代码同样通过Code::Block向导生成，在XP和Ubuntu下生成的源代码没有什么区别。在Ubuntu下编译运行的结果如图。

    程序包含4个文件：
 

1. HelloWorld.h
3. #ifndef HELLOWORLDAPP_H
5. #define HELLOWORLDAPP_H
9. #include 
13. class HelloWorldApp : public wxApp
15. {
17.     public:
19.         virtual bool OnInit();
21. };
25. #endif // HELLOWORLDAPP_H
27. HelloWorld.cpp
29. #ifdef WX_PRECOMP
31. #include "wx_pch.h"
33. #endif
37. #ifdef __BORLANDC__
39. #pragma hdrstop
41. #endif //__BORLANDC__
45. #include "HelloWorldApp.h"
47. #include "HelloWorldMain.h"
51. IMPLEMENT_APP(HelloWorldApp);
55. bool HelloWorldApp::OnInit()
57. {
59.     HelloWorldFrame* frame = new HelloWorldFrame(0L, _("Hello World!"));
63.     frame->Show();
67.     return true;
69. }
71. HelloWorldMain.h
73. #ifndef HELLOWORLDMAIN_H
75. #define HELLOWORLDMAIN_H
79. #ifndef WX_PRECOMP
81.     #include 
83. #endif
87. #include "HelloWorldApp.h"
91. class HelloWorldFrame: public wxFrame
93. {
95.     public:
97.         HelloWorldFrame(wxFrame *frame, const wxString& title);
99.         ~HelloWorldFrame();
101.     private:
103.         enum
105.         {
107.             idMenuQuit = 1000,
109.             idMenuAbout
111.         };
113.         void OnClose(wxCloseEvent& event);
115.         void OnQuit(wxCommandEvent& event);
117.         void OnAbout(wxCommandEvent& event);
119.         DECLARE_EVENT_TABLE()
121. };
127. #endif // HELLOWORLDMAIN_H
129. HelloWorldMain.cpp
131. #ifdef WX_PRECOMP
133. #include "wx_pch.h"
135. #endif
139. #ifdef __BORLANDC__
141. #pragma hdrstop
143. #endif //__BORLANDC__
147. #include "HelloWorldMain.h"
151. //helper functions
153. enum wxbuildinfoformat {
155.     short_f, long_f };
159. wxString wxbuildinfo(wxbuildinfoformat format)
161. {
163.     wxString wxbuild(wxVERSION_STRING);
167.     if (format == long_f )
169.     {
171. #if defined(__WXMSW__)
173.         wxbuild << _T("-Windows");
175. #elif defined(__WXMAC__)
177.         wxbuild << _T("-Mac");
179. #elif defined(__UNIX__)
181.         wxbuild << _T("-Linux");
183. #endif
187. #if wxUSE_UNICODE
189.         wxbuild << _T("-Unicode build");
191. #else
193.         wxbuild << _T("-ANSI build");
195. #endif // wxUSE_UNICODE
197.     }
201.     return wxbuild;
203. }
207. BEGIN_EVENT_TABLE(HelloWorldFrame, wxFrame)
209.     EVT_CLOSE(HelloWorldFrame::OnClose)
211.     EVT_MENU(idMenuQuit, HelloWorldFrame::OnQuit)
213.     EVT_MENU(idMenuAbout, HelloWorldFrame::OnAbout)
215. END_EVENT_TABLE()
219. HelloWorldFrame::HelloWorldFrame(wxFrame *frame, const wxString& title)
221.     : wxFrame(frame, -1, title)
223. {
225. #if wxUSE_MENUS
227.     // create a menu bar
229.     wxMenuBar* mbar = new wxMenuBar();
231.     wxMenu* fileMenu = new wxMenu(_T(""));
233.     fileMenu->Append(idMenuQuit, _("&Quit/tAlt-F4"), _("Quit the application"));
235.     mbar->Append(fileMenu, _("&File"));
239.     wxMenu* helpMenu = new wxMenu(_T(""));
241.     helpMenu->Append(idMenuAbout, _("&About/tF1"), _("Show info about this application"));
243.     mbar->Append(helpMenu, _("&Help"));
247.     SetMenuBar(mbar);
249. #endif // wxUSE_MENUS
251. #if wxUSE_STATUSBAR
253.     // create a status bar with some information about the used wxWidgets version
255.     CreateStatusBar(2);
257.     SetStatusText(_("Hello World!"),0);
259.     SetStatusText(wxbuildinfo(short_f), 1);
261. #endif // wxUSE_STATUSBAR
265. }
271. HelloWorldFrame::~HelloWorldFrame()
273. {
275. }
279. void HelloWorldFrame::OnClose(wxCloseEvent &event)
281. {
283.     Destroy();
285. }
289. void HelloWorldFrame::OnQuit(wxCommandEvent &event)
291. {
293.     Destroy();
295. }
299. void HelloWorldFrame::OnAbout(wxCommandEvent &event)
301. {
303.     wxString msg = wxbuildinfo(long_f);
305.     wxMessageBox(msg, _("Welcome to..."));
307. }

    从程序代码中，我们
    1）看不到WinMain或者是main，那么程序是从那里开始执行的呢？
    2）看不到CreateWindowEx或者是gtk_window_new，主窗口是如何产生的呢？
    3）看不到消息循环 while (GetMessage (&messages, NULL, 0, 0))  或者是gtk_main ()，程序如何推动的呢？
    4）在XP下使用SDK API，在Ubuntu下使用GTK，但是wxWidgets应用程序在Window XP下的源代码和Ubuntu下的源代码几乎完全一致，wxWidgets如何实现的呢？
    显然，wxWidgets在背后为我们做了大量的工作。

    2 wxWidgets 程序生因死果
   从1－3的程序里可以看出，这个简单的程序里有两个主要的类：HelloWorldMain和HelloWorldFrame。分别继承于wxApp和wxFrame。其中wxApp代表了程序主体，wxFrame代表一个主框窗口。从这两个类里看不出程序的入口，那么程序是从哪里开始执行的呢？

    2－1 程序入口
    仔细分析程序，在HelloWorld.cpp中，我们发现了一个宏IMPLEMENT_APP(HelloWorldApp)，这究竟代表了什么呢？
    查看wxWidgets源代码，我们可以在wx/app.h中发现IMPLEMENT_APP的定义：

1.  wx/app.h
3. #define wxTheApp wx_static_cast(wxApp*, wxApp::GetInstance())
5. // Use this macro exactly once, the argument is the name of the wxApp-derived
6. // class which is the class of your application.
7. #define IMPLEMENT_APP(appname)              /
8.     IMPLEMENT_APP_NO_THEMES(appname)        /
9.     IMPLEMENT_WX_THEME_SUPPORT
12. // Same as IMPLEMENT_APP() normally but doesn't include themes support in
13. // wxUniversal builds
14. #define IMPLEMENT_APP_NO_THEMES(appname)    /
15.     IMPLEMENT_APP_NO_MAIN(appname)          /
16.     IMPLEMENT_WXWIN_MAIN
18. // Use this macro if you want to define your own main() or WinMain() function
19. // and call wxEntry() from there.
20. #define IMPLEMENT_APP_NO_MAIN(appname)                                      /
21.     wxAppConsole *wxCreateApp()                                             /
22.     {                                                                       /
23.         wxAppConsole::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE,         /
24.                                         "your program");                    /
25.         return new appname;                                                 /
26.     }                                                                       /
27.     wxAppInitializer                                                        /
28.         wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp);        /
29.     DECLARE_APP(appname)                                                    /
30.     appname& wxGetApp() { return *wx_static_cast(appname*, wxApp::GetInstance()); }
32. // this macro can be used multiple times and just allows you to use wxGetApp()
33. // function
34. #define DECLARE_APP(appname) extern appname& wxGetApp();

     其中 IMPLEMENT_WXWIN_MAIN针对不同平台有不同的定义，wxWidgets通过定义不同的宏来区分：

1. #if defined(__WXPALMOS__)
2.         #include "wx/palmos/app.h"
3.     #elif defined(__WXMSW__)
4.         #include "wx/msw/app.h"
5.     #elif defined(__WXMOTIF__)
6.         #include "wx/motif/app.h"
7.     #elif defined(__WXMGL__)
8.         #include "wx/mgl/app.h"
9.     #elif defined(__WXDFB__)
10.         #include "wx/dfb/app.h"
11.     #elif defined(__WXGTK20__)
12.         #include "wx/gtk/app.h"
13.     #elif defined(__WXGTK__)
14.         #include "wx/gtk1/app.h"
15.     #elif defined(__WXX11__)
16.         #include "wx/x11/app.h"
17.     #elif defined(__WXMAC__)
18.         #include "wx/mac/app.h"
19.     #elif defined(__WXCOCOA__)
20.         #include "wx/cocoa/app.h"
21.     #elif defined(__WXPM__)
22.         #include "wx/os2/app.h"
23.     #endif

    这样，不同的平台引用相应的文件，实现不同平台下的功能。
    在GTK下，IMPLEMENT_WXWIN_MAIN的定义如下：

1.  #define IMPLEMENT_WXWIN_MAIN_CONSOLE /
2.         int main(int argc, char **argv) { return wxEntry(argc, argv); }
4.     // port-specific header could have defined it already in some special way
5.     #ifndef IMPLEMENT_WXWIN_MAIN
6.         #define IMPLEMENT_WXWIN_MAIN IMPLEMENT_WXWIN_MAIN_CONSOLE
7.     #endif 

    而Window下，定义于wx/msw/app.h中：

1. #define IMPLEMENT_WXWIN_MAIN /
2.     extern "C" int WINAPI WinMain(HINSTANCE hInstance,                    /
3.                                   HINSTANCE hPrevInstance,                /
4.                                   wxCmdLineArgType lpCmdLine,             /
5.                                   int nCmdShow)                           /
6.     {                                                                     /
7.         return wxEntry(hInstance, hPrevInstance, lpCmdLine, nCmdShow);    /
8.     }                                                                     /
9.     IMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD

    我们把IMPLEMENT_APP(HelloWorldApp)展开，在GTK下为：

1.    wxAppConsole *wxCreateApp()                                             
2.     {                                                                       
3.         wxAppConsole::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE,         
4.                                         "your program");                  
5.         return new HelloWorldApp;                                                 
6.     }                                                                      
7.     wxAppInitializer                                                       
8.         wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp);       
9.    extern HelloWorldApp& wxGetApp();                                              
10.     HelloWorldApp& wxGetApp() { return *wx_static_cast(HelloWorldApp*, wxApp::GetInstance()); }
11.   
12.    int main(int argc, char **argv) { return wxEntry(argc, argv); }

    而在Window下，为：

1.      wxAppConsole *wxCreateApp()                                             
2.     {                                                                       
3.         wxAppConsole::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE,         
4.                                         "your program");                  
5.         return new HelloWorldApp;                                                 
6.     }                                                                      
7.     wxAppInitializer                                                       
8.         wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp);       
9.    extern HelloWorldApp& wxGetApp();                                              
10.     HelloWorldApp& wxGetApp() { return *wx_static_cast(HelloWorldApp*, wxApp::GetInstance()); }
11.   
12.    int main(int argc, char **argv) { return wxEntry(argc, argv); }
13.    extern "C" int WINAPI WinMain(HINSTANCE hInstance,                    
14.                                   HINSTANCE hPrevInstance,               
15.                                   wxCmdLineArgType lpCmdLine,             
16.                                   int nCmdShow)                         
17.     {                                                                    
18.         return wxEntry(hInstance, hPrevInstance, lpCmdLine, nCmdShow);    
19.     }            

    第一步，程序的入口 main（...）或 WinMain(...)我们找到了。

     2－2 程序初始化
     以MSW（Window下为例子）说明。
     WinMain(...)很简单，只是调用了函数

1. int wxEntry(HINSTANCE hInstance,
2.                         HINSTANCE WXUNUSED(hPrevInstance),
3.                         wxCmdLineArgType WXUNUSED(pCmdLine),
4.                         int nCmdShow)，

     wxEntry定义在common/init.cpp中，wxEntry又调用了函数int wxEntry(int& argc, wxChar **argv)，进而又调用了函数int wxEntryReal(int& argc, wxChar **argv)。我们来看一下函数

1. int wxEntryReal(int& argc, wxChar **argv)
2. {
3.     // library initialization
4.     if ( !wxEntryStart(argc, argv) )
5.     {
6. #if wxUSE_LOG
7.         // flush any log messages explaining why we failed
8.         delete wxLog::SetActiveTarget(NULL);
9. #endif
10.         return -1;
11.     }
13.     // if wxEntryStart succeeded, we must call wxEntryCleanup even if the code
14.     // below returns or throws
15.     wxCleanupOnExit cleanupOnExit;
17.     WX_SUPPRESS_UNUSED_WARN(cleanupOnExit);
19.     wxTRY
20.     {
22.         // app initialization
23.         if ( !wxTheApp->CallOnInit() )
24.         {
25.             // don't call OnExit() if OnInit() failed
26.             return -1;
27.         }
29.         // ensure that OnExit() is called if OnInit() had succeeded
30.         class CallOnExit
31.         {
32.         public:
33.             ~CallOnExit() { wxTheApp->OnExit(); }
34.         } callOnExit;
36.         WX_SUPPRESS_UNUSED_WARN(callOnExit);
38.         // app execution
39.         return wxTheApp->OnRun();
40.     }
41.     wxCATCH_ALL( wxTheApp->OnUnhandledException(); return -1; )
42. }

    整个程序的初始化，推动过程都在此函数中。其中初始化过程调用wxEntryStart，本节主要讨论wxEntryStart函数为我们做了些什么。

1. bool wxEntryStart(int& argc, wxChar **argv)
2. {
3.     // do minimal, always necessary, initialization
4.     // --------------------------------------------
6.     // initialize wxRTTI
7.     if ( !DoCommonPreInit() )
8.     {
9.         return false;
10.     }
13.     // first of all, we need an application object
14.     // -------------------------------------------
16.     // the user might have already created it himself somehow
17.     wxAppPtr app(wxTheApp);
18.     if ( !app.get() )
19.     {
20.         // if not, he might have used IMPLEMENT_APP() to give us a function to
21.         // create it
22.         wxAppInitializerFunction fnCreate = wxApp::GetInitializerFunction();
24.         if ( fnCreate )
25.         {
26.             // he did, try to create the custom wxApp object
27.             app.Set((*fnCreate)());
28.         }
29.     }
31.     if ( !app.get() )
32.     {
33.         // either IMPLEMENT_APP() was not used at all or it failed -- in any
34.         // case we still need something
35.         app.Set(new wxDummyConsoleApp);
36.     }
39.     // wxApp initialization: this can be customized
40.     // --------------------------------------------
42.     if ( !app->Initialize(argc, argv) )
43.     {
44.         return false;
45.     }
47.     wxCallAppCleanup callAppCleanup(app.get());
49.     // for compatibility call the old initialization function too
50.     if ( !app->OnInitGui() )
51.         return false;
54.     // common initialization after wxTheApp creation
55.     // ---------------------------------------------
57.     if ( !DoCommonPostInit() )
58.         return false;
61.     // prevent the smart pointer from destroying its contents
62.     app.release();
64.     // and the cleanup object from doing cleanup
65.     callAppCleanup.Dismiss();
67. #if wxUSE_LOG
68.     // now that we have a valid wxApp (wxLogGui would have crashed if we used
69.     // it before now), we can delete the temporary sink we had created for the
70.     // initialization messages -- the next time logging function is called, the
71.     // sink will be recreated but this time wxAppTraits will be used
72.     delete wxLog::SetActiveTarget(NULL);
73. #endif // wxUSE_LOG
75.     return true;
76. }

     wxEntryStart为我们生成了一个application object－－wxTheApp。我们可以从app.h中发现wxTheApp的定义：    
     #define wxTheApp wx_static_cast(wxApp*, wxApp::GetInstance())
     而 wxApp::GetInstance()返回的是定义于wxApp基类wxAppConsole中的static变量：
     static wxAppConsole *GetInstance() { return ms_appInstance; }
     但是，wxApp（本例中为HelloWorldApp）是如何被创建的？ms_appInstance又是何时被赋值的呢？答案在 wxEntryStart函数中：

       wxAppInitializerFunction fnCreate = wxApp::GetInitializerFunction();
       app.Set((*fnCreate)());
      
      通过wxApp::GetInitializerFunction返回的函数指针，创建了一个HelloWorldApp实例。wxApp::GetInitializerFunction()返回的是wxApp的静态变量ms_appInitFn（定义在基类wxAppConsole）。接下来的问题是静态变量ms_appInitFn是如何、是什么时候被赋值的呢？这要回到宏IMPLEMENT_APP(HelloWorldApp)中，在展开的结果中，可以看到一个全局变量：
    wxAppInitializer wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp);    
    wxTheAppInitializer在执行WinMain之前首先生成。而wxAppInitializer的定义很简单，就是在构造函数里为 wxApp::ms_appInitFn赋值：

1.      class WXDLLIMPEXP_BASE wxAppInitializer
2.     {
3.     public:
4.         wxAppInitializer(wxAppInitializerFunction fn)
5.         { wxApp::SetInitializerFunction(fn); }
6.     };  
7.      

    当wxTheAppInitializer生成后，wxApp::ms_appInitFn赋值为wxCreateApp，而wxCreateApp是IMPLEMENT_APP(HelloWorldApp)展开的一部分，创建HelloWorldApp实例。
    ms_appInstance的赋值很简单，在wxAppConsole的构造函数中完成。
    至此，application object－－wxTheApp创建的来龙去脉就清楚了。
    application object－－wxTheApp（本例中为HelloWorldApp的实例），EntryStart调用app->Initialize(argc, argv)。Initialize为虚函数，HelloWorldApp并没有改写，因此实际调用wxApp的Initialize。wxApp在msw/app.cpp（当然对于GTK平台应该在gtk/app.cpp中，参加前面的说明）实现：

1. //msw/app.cpp
3. //// Initialize
4. bool wxApp::Initialize(int& argc, wxChar **argv)
5. {
6.     if ( !wxAppBase::Initialize(argc, argv) )
7.         return false;
9.     // ensure that base cleanup is done if we return too early
10.     wxCallBaseCleanup callBaseCleanup(this);
12. #ifdef __WXWINCE__
13.     wxString tmp = GetAppName();
14.     tmp += wxT("ClassName");
15.     wxCanvasClassName = wxStrdup( tmp.c_str() );
16.     tmp += wxT("NR");
17.     wxCanvasClassNameNR = wxStrdup( tmp.c_str() );
18.     HWND hWnd = FindWindow( wxCanvasClassNameNR, NULL );
19.     if (hWnd)
20.     {
21.         SetForegroundWindow( (HWND)(((DWORD)hWnd)|0x01) );
22.         return false;
23.     }
24. #endif
26. #if !defined(__WXMICROWIN__)
27.     InitCommonControls();
28. #endif // !defined(__WXMICROWIN__)
30. #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
31.     SHInitExtraControls();
32. #endif
34. #ifndef __WXWINCE__
35.     // Don't show a message box if a function such as SHGetFileInfo
36.     // fails to find a device.
37.     SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
38. #endif
40.     wxOleInitialize();
42.     RegisterWindowClasses();
44.     wxWinHandleHash = new wxWinHashTable(wxKEY_INTEGER, 100);
46. #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
47.     wxSetKeyboardHook(true);
48. #endif
50.     callBaseCleanup.Dismiss();
52.     return true;
53. }

    在此我们可以发现窗口注册 RegisterWindowClasses()等其他初始化过程。而RegisterWindowClasses()的定义为：

1. bool wxApp::RegisterWindowClasses()
2. {
3.     WNDCLASS wndclass;
4.     wxZeroMemory(wndclass);
6.     // for each class we register one with CS_(V|H)REDRAW style and one
7.     // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
8.     static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
9.     static const long styleNoRedraw = CS_DBLCLKS;
11.     // the fields which are common to all classes
12.     wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
13.     wndclass.hInstance     = wxhInstance;
14.     wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
16.     // register the class for all normal windows
17.     wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
18.     wndclass.lpszClassName = wxCanvasClassName;
19.     wndclass.style         = styleNormal;
21.     if ( !RegisterClass(&wndclass) )
22.     {
23.         wxLogLastError(wxT("RegisterClass(frame)"));
24.     }
26.     // "no redraw" frame
27.     wndclass.lpszClassName = wxCanvasClassNameNR;
28.     wndclass.style         = styleNoRedraw;
30.     if ( !RegisterClass(&wndclass) )
31.     {
32.         wxLogLastError(wxT("RegisterClass(no redraw frame)"));
33.     }
35.     // Register the MDI frame window class.
36.     wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
37.     wndclass.lpszClassName = wxMDIFrameClassName;
38.     wndclass.style         = styleNormal;
40.     if ( !RegisterClass(&wndclass) )
41.     {
42.         wxLogLastError(wxT("RegisterClass(MDI parent)"));
43.     }
45.     // "no redraw" MDI frame
46.     wndclass.lpszClassName = wxMDIFrameClassNameNoRedraw;
47.     wndclass.style         = styleNoRedraw;
49.     if ( !RegisterClass(&wndclass) )
50.     {
51.         wxLogLastError(wxT("RegisterClass(no redraw MDI parent frame)"));
52.     }
54.     // Register the MDI child frame window class.
55.     wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
56.     wndclass.lpszClassName = wxMDIChildFrameClassName;
57.     wndclass.style         = styleNormal;
59.     if ( !RegisterClass(&wndclass) )
60.     {
61.         wxLogLastError(wxT("RegisterClass(MDI child)"));
62.     }
64.     // "no redraw" MDI child frame
65.     wndclass.lpszClassName = wxMDIChildFrameClassNameNoRedraw;
66.     wndclass.style         = styleNoRedraw;
68.     if ( !RegisterClass(&wndclass) )
69.     {
70.         wxLogLastError(wxT("RegisterClass(no redraw MDI child)"));
71.     }
73.     return true;
74. }

    呵呵，Win32SDK的东西终于露面了。程序初始化过程也显山露水了。主窗口的创建呢？下一小节接着分析。

    2－3 窗口创建过程
    前面说过，主窗口创建由wxFrame负责，wxFrame（本例中为HelloWorldFrame）如何实现的呢？还是回到wxEntryReal函数中。调用wxEntryStart结束后，程序接着调用了：
    wxTheApp->CallOnInit()
    由上面的分析，我们已经知道wxTheApp是一个application object，相当于一个HelloWorldApp的全局变量。CallOnInit()调用了OnInit。OnInit是一个虚函数，在HelloWorldApp中重写了：

1.     bool HelloWorldApp::OnInit()
3.     {
5.         HelloWorldFrame* frame = new HelloWorldFrame(0L, _("Hello World!"));
9.         frame->Show();
13.         return true;
15.     }

    绕了一圈，终于到了主窗口的创建过程了。
    函数中创建了一个HelloWorldFrame实例，并调用 Show()显示。不用怀疑，wxWidgets肯定做了大量幕后工作。
    HelloWorldFrame的构造函数调用了基类的构造函数：
    HelloWorldFrame::HelloWorldFrame(wxFrame *frame, const wxString& title)
    : wxFrame(frame, -1, title)
   ｛｝
    先看一下wxFrame的类层次关系，如下图：

       真正的  wxFrame(frame, -1, title)定义在wxTopLevelWindowMSW中（图中显示的是GTK下，到了Window平台下为wxTopLevelWindowMSW，至于如何实现的已经不是新鲜事，参见前面的说明）：

1.     wxTopLevelWindowMSW(wxWindow *parent,
2.                         wxWindowID id,
3.                         const wxString& title,
4.                         const wxPoint& pos = wxDefaultPosition,
5.                         const wxSize& size = wxDefaultSize,
6.                         long style = wxDEFAULT_FRAME_STYLE,
7.                         const wxString& name = wxFrameNameStr)
8.     {
9.         Init();
11.         (void)Create(parent, id, title, pos, size, style, name);
12.     }

    Create(parent, id, title, pos, size, style, name)定义于msw/toplevel.cpp中（当然，对于GTK来说定义于jdk/toplevel.cpp中）。在这里我们还可以发现窗口过程的实现。
    Create最终又调用wxWindowMSW中的MSWCreate

1. bool wxWindowMSW::MSWCreate(const wxChar *wclass,
2.                             const wxChar *title,
3.                             const wxPoint& pos,
4.                             const wxSize& size,
5.                             WXDWORD style,
6.                             WXDWORD extendedStyle)
7. {
8.     // choose the position/size for the new window
9.     int x, y, w, h;
10.     (void)MSWGetCreateWindowCoords(pos, size, x, y, w, h);
12.     // controlId is menu handle for the top level windows, so set it to 0
13.     // unless we're creating a child window
14.     int controlId = style & WS_CHILD ? GetId() : 0;
16.     // for each class "Foo" we have we also have "FooNR" ("no repaint") class
17.     // which is the same but without CS_[HV]REDRAW class styles so using it
18.     // ensures that the window is not fully repainted on each resize
19.     wxString className(wclass);
20.     if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) )
21.     {
22.         className += wxT("NR");
23.     }
25.     // do create the window
26.     wxWindowCreationHook hook(this);
28.     m_hWnd = (WXHWND)::CreateWindowEx
29.                        (
30.                         extendedStyle,
31.                         className,
32.                         title ? title : m_windowName.c_str(),
33.                         style,
34.                         x, y, w, h,
35.                         (HWND)MSWGetParent(),
36.                         (HMENU)controlId,
37.                         wxGetInstance(),
38.                         NULL                        // no extra data
39.                        );
41.     if ( !m_hWnd )
42.     {
43.         wxLogSysError(_("Can't create window of class %s"), className.c_str());
45.         return false;
46.     }
48.     SubclassWin(m_hWnd);
50.     return true;
51. }

    至此主窗口真正生成。主窗口生成后，在HelloWorldFrame构造函数中为主窗口增加菜单栏、状态栏等。

    2－4 消息循环，程序推动
    主窗口生成后，程序如何推动的呢？我们主要两个地方：
    1） 回到wxEntryReal函数，可以看到：
     // app execution
        return wxTheApp->OnRun();
    程序进入循环等待。
    2）在HelloWorldFrame中，我们可以看到消息映射表
    BEGIN_EVENT_TABLE(HelloWorldFrame, wxFrame)
        EVT_CLOSE(HelloWorldFrame::OnClose)
        EVT_MENU(idMenuQuit, HelloWorldFrame::OnQuit)
        EVT_MENU(idMenuAbout, HelloWorldFrame::OnAbout)
    END_EVENT_TABLE()
    正是这两项推动程序运行。
    具体细节将在以后分析。

    3 结论：wxWidgets程序执行过程
     通过以上分析，可以看出wxWidgets程序一般执行过程为：
     1）根据平台不同，函数main，WinMain或类似的函数运行（这个函数是由wxWidgets提供的，并不是应用程序）。wxWidgets初始化内部数据结构，创建一个wxApp实例（本例中为HelloWorldApp）。
    2）wxWidgets调用HelloWorldApp::OnInit，创建一个wxFrame实例（本例中为HelloWorldFrame）。
    3）HelloWorldFrame构造函数通过wxFrame的构造函数创建主窗口，并且增加菜单栏、状态条等。
    4）HelloWorldApp::OnInit显示frame.
    5）wxWidgets开始消息循环，等待事件发生，并把事件分配到相应的处理函数。
    当主窗口销毁时，程序也随之结束。