src/msw/app.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/app.cpp
   3 // Purpose:     wxApp
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ===========================================================================
  13 // declarations
  14 // ===========================================================================
  15
  16 // ---------------------------------------------------------------------------
  17 // headers
  18 // ---------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #if defined(__BORLANDC__)
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/msw/wrapcctl.h"
  29     #include "wx/dynarray.h"
  30     #include "wx/frame.h"
  31     #include "wx/app.h"
  32     #include "wx/utils.h"
  33     #include "wx/gdicmn.h"
  34     #include "wx/pen.h"
  35     #include "wx/brush.h"
  36     #include "wx/cursor.h"
  37     #include "wx/icon.h"
  38     #include "wx/palette.h"
  39     #include "wx/dc.h"
  40     #include "wx/dialog.h"
  41     #include "wx/msgdlg.h"
  42     #include "wx/intl.h"
  43     #include "wx/wxchar.h"
  44     #include "wx/log.h"
  45     #include "wx/module.h"
  46 #endif
  47
  48 #include "wx/apptrait.h"
  49 #include "wx/filename.h"
  50 #include "wx/dynlib.h"
  51 #include "wx/evtloop.h"
  52
  53 #include "wx/msw/private.h"
  54 #include "wx/msw/ole/oleutils.h"
  55
  56 #if wxUSE_TOOLTIPS
  57     #include "wx/tooltip.h"
  58 #endif // wxUSE_TOOLTIPS
  59
  60 // OLE is used for drag-and-drop, clipboard, OLE Automation..., but some
  61 // compilers don't support it (missing headers, libs, ...)
  62 #if defined(__GNUWIN32_OLD__) || defined(__SYMANTEC__) || defined(__SALFORDC__)
  63     #undef wxUSE_OLE
  64
  65     #define  wxUSE_OLE 0
  66 #endif // broken compilers
  67
  68 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
  69     #include <ole2.h>
  70     #include <aygshell.h>
  71 #endif
  72
  73 #if wxUSE_OLE
  74     #include <ole2.h>
  75 #endif
  76
  77 #include <string.h>
  78 #include <ctype.h>
  79
  80 // For MB_TASKMODAL
  81 #ifdef __WXWINCE__
  82 #include "wx/msw/wince/missing.h"
  83 #endif
  84
  85 // instead of including <shlwapi.h> which is not part of the core SDK and not
  86 // shipped at all with other compilers, we always define the parts of it we
  87 // need here ourselves
  88 //
  89 // NB: DLLVER_PLATFORM_WINDOWS will be defined if shlwapi.h had been somehow
  90 //     included already
  91 #ifndef DLLVER_PLATFORM_WINDOWS
  92     // hopefully we don't need to change packing as DWORDs should be already
  93     // correctly aligned
  94     struct DLLVERSIONINFO
  95     {
  96         DWORD cbSize;
  97         DWORD dwMajorVersion;                   // Major version
  98         DWORD dwMinorVersion;                   // Minor version
  99         DWORD dwBuildNumber;                    // Build number
 100         DWORD dwPlatformID;                     // DLLVER_PLATFORM_*
 101     };
 102
 103     typedef HRESULT (CALLBACK* DLLGETVERSIONPROC)(DLLVERSIONINFO *);
 104 #endif // defined(DLLVERSIONINFO)
 105
 106
 107 // ---------------------------------------------------------------------------
 108 // global variables
 109 // ---------------------------------------------------------------------------
 110
 111 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 112 extern void wxSetKeyboardHook(bool doIt);
 113 #endif
 114
 115 // NB: all "NoRedraw" classes must have the same names as the "normal" classes
 116 //     with NR suffix - wxWindow::MSWCreate() supposes this
 117 #ifdef __WXWINCE__
 118 WXDLLIMPEXP_CORE       wxChar *wxCanvasClassName;
 119 WXDLLIMPEXP_CORE       wxChar *wxCanvasClassNameNR;
 120 #else
 121 WXDLLIMPEXP_CORE const wxChar *wxCanvasClassName        = wxT("wxWindowClass");
 122 WXDLLIMPEXP_CORE const wxChar *wxCanvasClassNameNR      = wxT("wxWindowClassNR");
 123 #endif
 124 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassName      = wxT("wxMDIFrameClass");
 125 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassNameNoRedraw = wxT("wxMDIFrameClassNR");
 126 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassName = wxT("wxMDIChildFrameClass");
 127 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassNameNoRedraw = wxT("wxMDIChildFrameClassNR");
 128
 129 // ----------------------------------------------------------------------------
 130 // private functions
 131 // ----------------------------------------------------------------------------
 132
 133 LRESULT WXDLLEXPORT APIENTRY wxWndProc(HWND, UINT, WPARAM, LPARAM);
 134
 135 // ===========================================================================
 136 // wxGUIAppTraits implementation
 137 // ===========================================================================
 138
 139 // private class which we use to pass parameters from BeforeChildWaitLoop() to
 140 // AfterChildWaitLoop()
 141 struct ChildWaitLoopData
 142 {
 143     ChildWaitLoopData(wxWindowDisabler *wd_, wxWindow *winActive_)
 144     {
 145         wd = wd_;
 146         winActive = winActive_;
 147     }
 148
 149     wxWindowDisabler *wd;
 150     wxWindow *winActive;
 151 };
 152
 153 void *wxGUIAppTraits::BeforeChildWaitLoop()
 154 {
 155     /*
 156        We use a dirty hack here to disable all application windows (which we
 157        must do because otherwise the calls to wxYield() could lead to some very
 158        unexpected reentrancies in the users code) but to avoid losing
 159        focus/activation entirely when the child process terminates which would
 160        happen if we simply disabled everything using wxWindowDisabler. Indeed,
 161        remember that Windows will never activate a disabled window and when the
 162        last childs window is closed and Windows looks for a window to activate
 163        all our windows are still disabled. There is no way to enable them in
 164        time because we don't know when the childs windows are going to be
 165        closed, so the solution we use here is to keep one special tiny frame
 166        enabled all the time. Then when the child terminates it will get
 167        activated and when we close it below -- after reenabling all the other
 168        windows! -- the previously active window becomes activated again and
 169        everything is ok.
 170      */
 171     wxBeginBusyCursor();
 172
 173     // first disable all existing windows
 174     wxWindowDisabler *wd = new wxWindowDisabler;
 175
 176     // then create an "invisible" frame: it has minimal size, is positioned
 177     // (hopefully) outside the screen and doesn't appear on the taskbar
 178     wxWindow *winActive = new wxFrame
 179                     (
 180                         wxTheApp->GetTopWindow(),
 181                         wxID_ANY,
 182                         wxEmptyString,
 183                         wxPoint(32600, 32600),
 184                         wxSize(1, 1),
 185                         wxDEFAULT_FRAME_STYLE | wxFRAME_NO_TASKBAR
 186                     );
 187     winActive->Show();
 188
 189     return new ChildWaitLoopData(wd, winActive);
 190 }
 191
 192 void wxGUIAppTraits::AlwaysYield()
 193 {
 194     wxYield();
 195 }
 196
 197 void wxGUIAppTraits::AfterChildWaitLoop(void *dataOrig)
 198 {
 199     wxEndBusyCursor();
 200
 201     ChildWaitLoopData * const data = (ChildWaitLoopData *)dataOrig;
 202
 203     delete data->wd;
 204
 205     // finally delete the dummy frame and, as wd has been already destroyed and
 206     // the other windows reenabled, the activation is going to return to the
 207     // window which had had it before
 208     data->winActive->Destroy();
 209
 210     // also delete the temporary data object itself
 211     delete data;
 212 }
 213
 214 bool wxGUIAppTraits::DoMessageFromThreadWait()
 215 {
 216     // we should return false only if the app should exit, i.e. only if
 217     // Dispatch() determines that the main event loop should terminate
 218     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 219     if ( !evtLoop || !evtLoop->Pending() )
 220     {
 221         // no events means no quit event
 222         return true;
 223     }
 224
 225     return evtLoop->Dispatch();
 226 }
 227
 228 DWORD wxGUIAppTraits::WaitForThread(WXHANDLE hThread)
 229 {
 230     // if we don't have a running event loop, we shouldn't wait for the
 231     // messages as we never remove them from the message queue and so we enter
 232     // an infinite loop as MsgWaitForMultipleObjects() keeps returning
 233     // WAIT_OBJECT_0 + 1
 234     if ( !wxEventLoop::GetActive() )
 235         return DoSimpleWaitForThread(hThread);
 236
 237     return ::MsgWaitForMultipleObjects
 238              (
 239                1,                   // number of objects to wait for
 240                (HANDLE *)&hThread,  // the objects
 241                false,               // wait for any objects, not all
 242                INFINITE,            // no timeout
 243                QS_ALLINPUT |        // return as soon as there are any events
 244                QS_ALLPOSTMESSAGE
 245              );
 246 }
 247
 248 wxPortId wxGUIAppTraits::GetToolkitVersion(int *majVer, int *minVer) const
 249 {
 250     OSVERSIONINFO info;
 251     wxZeroMemory(info);
 252
 253     // on Windows, the toolkit version is the same of the OS version
 254     // as Windows integrates the OS kernel with the GUI toolkit.
 255     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
 256     if ( ::GetVersionEx(&info) )
 257     {
 258         if ( majVer )
 259             *majVer = info.dwMajorVersion;
 260         if ( minVer )
 261             *minVer = info.dwMinorVersion;
 262     }
 263
 264 #if defined(__WXHANDHELD__) || defined(__WXWINCE__)
 265     return wxPORT_WINCE;
 266 #else
 267     return wxPORT_MSW;
 268 #endif
 269 }
 270
 271 // ===========================================================================
 272 // wxApp implementation
 273 // ===========================================================================
 274
 275 int wxApp::m_nCmdShow = SW_SHOWNORMAL;
 276
 277 // ---------------------------------------------------------------------------
 278 // wxWin macros
 279 // ---------------------------------------------------------------------------
 280
 281 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
 282
 283 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 284     EVT_IDLE(wxApp::OnIdle)
 285     EVT_END_SESSION(wxApp::OnEndSession)
 286     EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
 287 END_EVENT_TABLE()
 288
 289 // class to ensure that wxAppBase::CleanUp() is called if our Initialize()
 290 // fails
 291 class wxCallBaseCleanup
 292 {
 293 public:
 294     wxCallBaseCleanup(wxApp *app) : m_app(app) { }
 295     ~wxCallBaseCleanup() { if ( m_app ) m_app->wxAppBase::CleanUp(); }
 296
 297     void Dismiss() { m_app = NULL; }
 298
 299 private:
 300     wxApp *m_app;
 301 };
 302
 303 //// Initialize
 304 bool wxApp::Initialize(int& argc, wxChar **argv)
 305 {
 306     if ( !wxAppBase::Initialize(argc, argv) )
 307         return false;
 308
 309     // ensure that base cleanup is done if we return too early
 310     wxCallBaseCleanup callBaseCleanup(this);
 311
 312 #ifdef __WXWINCE__
 313     wxString tmp = GetAppName();
 314     tmp += wxT("ClassName");
 315     wxCanvasClassName = wxStrdup( tmp.c_str() );
 316     tmp += wxT("NR");
 317     wxCanvasClassNameNR = wxStrdup( tmp.c_str() );
 318     HWND hWnd = FindWindow( wxCanvasClassNameNR, NULL );
 319     if (hWnd)
 320     {
 321         SetForegroundWindow( (HWND)(((DWORD)hWnd)|0x01) );
 322         return false;
 323     }
 324 #endif
 325
 326 #if !defined(__WXMICROWIN__)
 327     InitCommonControls();
 328 #endif // !defined(__WXMICROWIN__)
 329
 330 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
 331     SHInitExtraControls();
 332 #endif
 333
 334 #ifndef __WXWINCE__
 335     // Don't show a message box if a function such as SHGetFileInfo
 336     // fails to find a device.
 337     SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
 338 #endif
 339
 340     wxOleInitialize();
 341
 342     RegisterWindowClasses();
 343
 344     wxWinHandleHash = new wxWinHashTable(wxKEY_INTEGER, 100);
 345
 346 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 347     wxSetKeyboardHook(true);
 348 #endif
 349
 350     callBaseCleanup.Dismiss();
 351
 352     return true;
 353 }
 354
 355 // ---------------------------------------------------------------------------
 356 // RegisterWindowClasses
 357 // ---------------------------------------------------------------------------
 358
 359 // TODO we should only register classes really used by the app. For this it
 360 //      would be enough to just delay the class registration until an attempt
 361 //      to create a window of this class is made.
 362 bool wxApp::RegisterWindowClasses()
 363 {
 364     WNDCLASS wndclass;
 365     wxZeroMemory(wndclass);
 366
 367     // for each class we register one with CS_(V|H)REDRAW style and one
 368     // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
 369     static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
 370     static const long styleNoRedraw = CS_DBLCLKS;
 371
 372     // the fields which are common to all classes
 373     wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
 374     wndclass.hInstance     = wxhInstance;
 375     wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
 376
 377     // register the class for all normal windows
 378     wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
 379     wndclass.lpszClassName = wxCanvasClassName;
 380     wndclass.style         = styleNormal;
 381
 382     if ( !RegisterClass(&wndclass) )
 383     {
 384         wxLogLastError(wxT("RegisterClass(frame)"));
 385     }
 386
 387     // "no redraw" frame
 388     wndclass.lpszClassName = wxCanvasClassNameNR;
 389     wndclass.style         = styleNoRedraw;
 390
 391     if ( !RegisterClass(&wndclass) )
 392     {
 393         wxLogLastError(wxT("RegisterClass(no redraw frame)"));
 394     }
 395
 396     // Register the MDI frame window class.
 397     wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
 398     wndclass.lpszClassName = wxMDIFrameClassName;
 399     wndclass.style         = styleNormal;
 400
 401     if ( !RegisterClass(&wndclass) )
 402     {
 403         wxLogLastError(wxT("RegisterClass(MDI parent)"));
 404     }
 405
 406     // "no redraw" MDI frame
 407     wndclass.lpszClassName = wxMDIFrameClassNameNoRedraw;
 408     wndclass.style         = styleNoRedraw;
 409
 410     if ( !RegisterClass(&wndclass) )
 411     {
 412         wxLogLastError(wxT("RegisterClass(no redraw MDI parent frame)"));
 413     }
 414
 415     // Register the MDI child frame window class.
 416     wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
 417     wndclass.lpszClassName = wxMDIChildFrameClassName;
 418     wndclass.style         = styleNormal;
 419
 420     if ( !RegisterClass(&wndclass) )
 421     {
 422         wxLogLastError(wxT("RegisterClass(MDI child)"));
 423     }
 424
 425     // "no redraw" MDI child frame
 426     wndclass.lpszClassName = wxMDIChildFrameClassNameNoRedraw;
 427     wndclass.style         = styleNoRedraw;
 428
 429     if ( !RegisterClass(&wndclass) )
 430     {
 431         wxLogLastError(wxT("RegisterClass(no redraw MDI child)"));
 432     }
 433
 434     return true;
 435 }
 436
 437 // ---------------------------------------------------------------------------
 438 // UnregisterWindowClasses
 439 // ---------------------------------------------------------------------------
 440
 441 bool wxApp::UnregisterWindowClasses()
 442 {
 443     bool retval = true;
 444
 445 #ifndef __WXMICROWIN__
 446     // MDI frame window class.
 447     if ( !::UnregisterClass(wxMDIFrameClassName, wxhInstance) )
 448     {
 449         wxLogLastError(wxT("UnregisterClass(MDI parent)"));
 450
 451         retval = false;
 452     }
 453
 454     // "no redraw" MDI frame
 455     if ( !::UnregisterClass(wxMDIFrameClassNameNoRedraw, wxhInstance) )
 456     {
 457         wxLogLastError(wxT("UnregisterClass(no redraw MDI parent frame)"));
 458
 459         retval = false;
 460     }
 461
 462     // MDI child frame window class.
 463     if ( !::UnregisterClass(wxMDIChildFrameClassName, wxhInstance) )
 464     {
 465         wxLogLastError(wxT("UnregisterClass(MDI child)"));
 466
 467         retval = false;
 468     }
 469
 470     // "no redraw" MDI child frame
 471     if ( !::UnregisterClass(wxMDIChildFrameClassNameNoRedraw, wxhInstance) )
 472     {
 473         wxLogLastError(wxT("UnregisterClass(no redraw MDI child)"));
 474
 475         retval = false;
 476     }
 477
 478     // canvas class name
 479     if ( !::UnregisterClass(wxCanvasClassName, wxhInstance) )
 480     {
 481         wxLogLastError(wxT("UnregisterClass(canvas)"));
 482
 483         retval = false;
 484     }
 485
 486     if ( !::UnregisterClass(wxCanvasClassNameNR, wxhInstance) )
 487     {
 488         wxLogLastError(wxT("UnregisterClass(no redraw canvas)"));
 489
 490         retval = false;
 491     }
 492 #endif // __WXMICROWIN__
 493
 494     return retval;
 495 }
 496
 497 void wxApp::CleanUp()
 498 {
 499     // all objects pending for deletion must be deleted first, otherwise we
 500     // would crash when they use wxWinHandleHash (and UnregisterWindowClasses()
 501     // call wouldn't succeed as long as any windows still exist), so call the
 502     // base class method first and only then do our clean up
 503     wxAppBase::CleanUp();
 504
 505 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 506     wxSetKeyboardHook(false);
 507 #endif
 508
 509     wxOleUninitialize();
 510
 511     // for an EXE the classes are unregistered when it terminates but DLL may
 512     // be loaded several times (load/unload/load) into the same process in
 513     // which case the registration will fail after the first time if we don't
 514     // unregister the classes now
 515     UnregisterWindowClasses();
 516
 517     delete wxWinHandleHash;
 518     wxWinHandleHash = NULL;
 519
 520 #ifdef __WXWINCE__
 521     free( wxCanvasClassName );
 522     free( wxCanvasClassNameNR );
 523 #endif
 524 }
 525
 526 // ----------------------------------------------------------------------------
 527 // wxApp ctor/dtor
 528 // ----------------------------------------------------------------------------
 529
 530 wxApp::wxApp()
 531 {
 532     m_printMode = wxPRINT_WINDOWS;
 533 }
 534
 535 wxApp::~wxApp()
 536 {
 537 }
 538
 539 // ----------------------------------------------------------------------------
 540 // wxApp idle handling
 541 // ----------------------------------------------------------------------------
 542
 543 void wxApp::OnIdle(wxIdleEvent& event)
 544 {
 545     wxAppBase::OnIdle(event);
 546
 547 #if wxUSE_DC_CACHEING
 548     // automated DC cache management: clear the cached DCs and bitmap
 549     // if it's likely that the app has finished with them, that is, we
 550     // get an idle event and we're not dragging anything.
 551     if (!::GetKeyState(MK_LBUTTON) && !::GetKeyState(MK_MBUTTON) && !::GetKeyState(MK_RBUTTON))
 552         wxDC::ClearCache();
 553 #endif // wxUSE_DC_CACHEING
 554 }
 555
 556 void wxApp::WakeUpIdle()
 557 {
 558     // Send the top window a dummy message so idle handler processing will
 559     // start up again.  Doing it this way ensures that the idle handler
 560     // wakes up in the right thread (see also wxWakeUpMainThread() which does
 561     // the same for the main app thread only)
 562     wxWindow *topWindow = wxTheApp->GetTopWindow();
 563     if ( topWindow )
 564     {
 565         if ( !::PostMessage(GetHwndOf(topWindow), WM_NULL, 0, 0) )
 566         {
 567             // should never happen
 568             wxLogLastError(wxT("PostMessage(WM_NULL)"));
 569         }
 570     }
 571 }
 572
 573 // ----------------------------------------------------------------------------
 574 // other wxApp event hanlders
 575 // ----------------------------------------------------------------------------
 576
 577 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
 578 {
 579     if (GetTopWindow())
 580         GetTopWindow()->Close(true);
 581 }
 582
 583 // Default behaviour: close the application with prompts. The
 584 // user can veto the close, and therefore the end session.
 585 void wxApp::OnQueryEndSession(wxCloseEvent& event)
 586 {
 587     if (GetTopWindow())
 588     {
 589         if (!GetTopWindow()->Close(!event.CanVeto()))
 590             event.Veto(true);
 591     }
 592 }
 593
 594 // ----------------------------------------------------------------------------
 595 // miscellaneous
 596 // ----------------------------------------------------------------------------
 597
 598 /* static */
 599 int wxApp::GetComCtl32Version()
 600 {
 601 #if defined(__WXMICROWIN__) || defined(__WXWINCE__)
 602     return 0;
 603 #else
 604     // cache the result
 605     //
 606     // NB: this is MT-ok as in the worst case we'd compute s_verComCtl32 twice,
 607     //     but as its value should be the same both times it doesn't matter
 608     static int s_verComCtl32 = -1;
 609
 610     if ( s_verComCtl32 == -1 )
 611     {
 612         // initally assume no comctl32.dll at all
 613         s_verComCtl32 = 0;
 614
 615         // we're prepared to handle the errors
 616         wxLogNull noLog;
 617
 618 #if wxUSE_DYNLIB_CLASS
 619         // do we have it?
 620         wxDynamicLibrary dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM);
 621
 622         // if so, then we can check for the version
 623         if ( dllComCtl32.IsLoaded() )
 624         {
 625             // now check if the function is available during run-time
 626             wxDYNLIB_FUNCTION( DLLGETVERSIONPROC, DllGetVersion, dllComCtl32 );
 627             if ( pfnDllGetVersion )
 628             {
 629                 DLLVERSIONINFO dvi;
 630                 dvi.cbSize = sizeof(dvi);
 631
 632                 HRESULT hr = (*pfnDllGetVersion)(&dvi);
 633                 if ( FAILED(hr) )
 634                 {
 635                     wxLogApiError(_T("DllGetVersion"), hr);
 636                 }
 637                 else
 638                 {
 639                     // this is incompatible with _WIN32_IE values, but
 640                     // compatible with the other values returned by
 641                     // GetComCtl32Version()
 642                     s_verComCtl32 = 100*dvi.dwMajorVersion +
 643                                         dvi.dwMinorVersion;
 644                 }
 645             }
 646
 647             // if DllGetVersion() is unavailable either during compile or
 648             // run-time, try to guess the version otherwise
 649             if ( !s_verComCtl32 )
 650             {
 651                 // InitCommonControlsEx is unique to 4.70 and later
 652                 void *pfn = dllComCtl32.GetSymbol(_T("InitCommonControlsEx"));
 653                 if ( !pfn )
 654                 {
 655                     // not found, must be 4.00
 656                     s_verComCtl32 = 400;
 657                 }
 658                 else // 4.70+
 659                 {
 660                     // many symbols appeared in comctl32 4.71, could use any of
 661                     // them except may be DllInstall()
 662                     pfn = dllComCtl32.GetSymbol(_T("InitializeFlatSB"));
 663                     if ( !pfn )
 664                     {
 665                         // not found, must be 4.70
 666                         s_verComCtl32 = 470;
 667                     }
 668                     else
 669                     {
 670                         // found, must be 4.71 or later
 671                         s_verComCtl32 = 471;
 672                     }
 673                 }
 674             }
 675         }
 676 #endif
 677     }
 678
 679     return s_verComCtl32;
 680 #endif // Microwin/!Microwin
 681 }
 682
 683 // Yield to incoming messages
 684
 685 bool wxApp::Yield(bool onlyIfNeeded)
 686 {
 687     // MT-FIXME
 688     static bool s_inYield = false;
 689
 690 #if wxUSE_LOG
 691     // disable log flushing from here because a call to wxYield() shouldn't
 692     // normally result in message boxes popping up &c
 693     wxLog::Suspend();
 694 #endif // wxUSE_LOG
 695
 696     if ( s_inYield )
 697     {
 698         if ( !onlyIfNeeded )
 699         {
 700             wxFAIL_MSG( wxT("wxYield called recursively" ) );
 701         }
 702
 703         return false;
 704     }
 705
 706     s_inYield = true;
 707
 708     // we don't want to process WM_QUIT from here - it should be processed in
 709     // the main event loop in order to stop it
 710     MSG msg;
 711     while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) &&
 712             msg.message != WM_QUIT )
 713     {
 714 #if wxUSE_THREADS
 715         wxMutexGuiLeaveOrEnter();
 716 #endif // wxUSE_THREADS
 717
 718         if ( !wxTheApp->Dispatch() )
 719             break;
 720     }
 721
 722     // if there are pending events, we must process them.
 723     ProcessPendingEvents();
 724
 725 #if wxUSE_LOG
 726     // let the logs be flashed again
 727     wxLog::Resume();
 728 #endif // wxUSE_LOG
 729
 730     s_inYield = false;
 731
 732     return true;
 733 }
 734
 735 #if wxUSE_EXCEPTIONS
 736
 737 // ----------------------------------------------------------------------------
 738 // exception handling
 739 // ----------------------------------------------------------------------------
 740
 741 bool wxApp::OnExceptionInMainLoop()
 742 {
 743     // ask the user about what to do: use the Win32 API function here as it
 744     // could be dangerous to use any wxWidgets code in this state
 745     switch (
 746             ::MessageBox
 747               (
 748                 NULL,
 749                 _T("An unhandled exception occurred. Press \"Abort\" to \
 750 terminate the program,\r\n\
 751 \"Retry\" to exit the program normally and \"Ignore\" to try to continue."),
 752                 _T("Unhandled exception"),
 753                 MB_ABORTRETRYIGNORE |
 754                 MB_ICONERROR|
 755                 MB_TASKMODAL
 756               )
 757            )
 758     {
 759         case IDABORT:
 760             throw;
 761
 762         default:
 763             wxFAIL_MSG( _T("unexpected MessageBox() return code") );
 764             // fall through
 765
 766         case IDRETRY:
 767             return false;
 768
 769         case IDIGNORE:
 770             return true;
 771     }
 772 }
 773
 774 #endif // wxUSE_EXCEPTIONS
 775
 776 // ----------------------------------------------------------------------------
 777 // deprecated event loop functions
 778 // ----------------------------------------------------------------------------
 779
 780 #if WXWIN_COMPATIBILITY_2_4
 781
 782 void wxApp::DoMessage(WXMSG *pMsg)
 783 {
 784     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 785     if ( evtLoop )
 786         evtLoop->ProcessMessage(pMsg);
 787 }
 788
 789 bool wxApp::DoMessage()
 790 {
 791     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 792     return evtLoop ? evtLoop->Dispatch() : false;
 793 }
 794
 795 bool wxApp::ProcessMessage(WXMSG* pMsg)
 796 {
 797     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 798     return evtLoop && evtLoop->PreProcessMessage(pMsg);
 799 }
 800
 801 #endif // WXWIN_COMPATIBILITY_2_4