src/msw/app.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21     #pragma implementation "app.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #if defined(__BORLANDC__)
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/frame.h"
  33     #include "wx/app.h"
  34     #include "wx/utils.h"
  35     #include "wx/gdicmn.h"
  36     #include "wx/pen.h"
  37     #include "wx/brush.h"
  38     #include "wx/cursor.h"
  39     #include "wx/icon.h"
  40     #include "wx/palette.h"
  41     #include "wx/dc.h"
  42     #include "wx/dialog.h"
  43     #include "wx/msgdlg.h"
  44     #include "wx/intl.h"
  45     #include "wx/dynarray.h"
  46     #include "wx/wxchar.h"
  47     #include "wx/icon.h"
  48     #include "wx/log.h"
  49 #endif
  50
  51 #include "wx/apptrait.h"
  52 #include "wx/filename.h"
  53 #include "wx/module.h"
  54 #include "wx/dynlib.h"
  55
  56 #include "wx/msw/private.h"
  57
  58 #if wxUSE_TOOLTIPS
  59     #include "wx/tooltip.h"
  60 #endif // wxUSE_TOOLTIPS
  61
  62 // OLE is used for drag-and-drop, clipboard, OLE Automation..., but some
  63 // compilers don't support it (missing headers, libs, ...)
  64 #if defined(__GNUWIN32_OLD__) || defined(__SYMANTEC__) || defined(__SALFORDC__)
  65     #undef wxUSE_OLE
  66
  67     #define  wxUSE_OLE 0
  68 #endif // broken compilers
  69
  70 #if wxUSE_OLE
  71     #include <ole2.h>
  72 #endif
  73
  74 #include <string.h>
  75 #include <ctype.h>
  76
  77 #include "wx/msw/wrapcctl.h"
  78
  79 // For MB_TASKMODAL
  80 #ifdef __WXWINCE__
  81 #include "wx/msw/wince/missing.h"
  82 #endif
  83
  84 #if (!defined(__MINGW32__) || wxCHECK_W32API_VERSION( 2, 0 )) && \
  85     !defined(__CYGWIN__) && !defined(__DIGITALMARS__) && !defined(__WXWINCE__) && \
  86     (!defined(_MSC_VER) || (_MSC_VER > 1100))
  87     #include <shlwapi.h>
  88 #endif
  89
  90 // ---------------------------------------------------------------------------
  91 // global variables
  92 // ---------------------------------------------------------------------------
  93
  94 extern wxList WXDLLEXPORT wxPendingDelete;
  95
  96 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
  97 extern void wxSetKeyboardHook(bool doIt);
  98 #endif
  99
 100 // NB: all "NoRedraw" classes must have the same names as the "normal" classes
 101 //     with NR suffix - wxWindow::MSWCreate() supposes this
 102 #ifdef __WXWINCE__
 103 WXDLLIMPEXP_CORE       wxChar *wxCanvasClassName;
 104 WXDLLIMPEXP_CORE       wxChar *wxCanvasClassNameNR;
 105 #else
 106 WXDLLIMPEXP_CORE const wxChar *wxCanvasClassName        = wxT("wxWindowClass");
 107 WXDLLIMPEXP_CORE const wxChar *wxCanvasClassNameNR      = wxT("wxWindowClassNR");
 108 #endif
 109 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassName      = wxT("wxMDIFrameClass");
 110 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassNameNoRedraw = wxT("wxMDIFrameClassNR");
 111 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassName = wxT("wxMDIChildFrameClass");
 112 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassNameNoRedraw = wxT("wxMDIChildFrameClassNR");
 113
 114 // ----------------------------------------------------------------------------
 115 // private functions
 116 // ----------------------------------------------------------------------------
 117
 118 LRESULT WXDLLEXPORT APIENTRY wxWndProc(HWND, UINT, WPARAM, LPARAM);
 119
 120 // ===========================================================================
 121 // wxGUIAppTraits implementation
 122 // ===========================================================================
 123
 124 // private class which we use to pass parameters from BeforeChildWaitLoop() to
 125 // AfterChildWaitLoop()
 126 struct ChildWaitLoopData
 127 {
 128     ChildWaitLoopData(wxWindowDisabler *wd_, wxWindow *winActive_)
 129     {
 130         wd = wd_;
 131         winActive = winActive_;
 132     }
 133
 134     wxWindowDisabler *wd;
 135     wxWindow *winActive;
 136 };
 137
 138 void *wxGUIAppTraits::BeforeChildWaitLoop()
 139 {
 140     /*
 141        We use a dirty hack here to disable all application windows (which we
 142        must do because otherwise the calls to wxYield() could lead to some very
 143        unexpected reentrancies in the users code) but to avoid losing
 144        focus/activation entirely when the child process terminates which would
 145        happen if we simply disabled everything using wxWindowDisabler. Indeed,
 146        remember that Windows will never activate a disabled window and when the
 147        last childs window is closed and Windows looks for a window to activate
 148        all our windows are still disabled. There is no way to enable them in
 149        time because we don't know when the childs windows are going to be
 150        closed, so the solution we use here is to keep one special tiny frame
 151        enabled all the time. Then when the child terminates it will get
 152        activated and when we close it below -- after reenabling all the other
 153        windows! -- the previously active window becomes activated again and
 154        everything is ok.
 155      */
 156     wxBeginBusyCursor();
 157
 158     // first disable all existing windows
 159     wxWindowDisabler *wd = new wxWindowDisabler;
 160
 161     // then create an "invisible" frame: it has minimal size, is positioned
 162     // (hopefully) outside the screen and doesn't appear on the taskbar
 163     wxWindow *winActive = new wxFrame
 164                     (
 165                         wxTheApp->GetTopWindow(),
 166                         wxID_ANY,
 167                         wxEmptyString,
 168                         wxPoint(32600, 32600),
 169                         wxSize(1, 1),
 170                         wxDEFAULT_FRAME_STYLE | wxFRAME_NO_TASKBAR
 171                     );
 172     winActive->Show();
 173
 174     return new ChildWaitLoopData(wd, winActive);
 175 }
 176
 177 void wxGUIAppTraits::AlwaysYield()
 178 {
 179     wxYield();
 180 }
 181
 182 void wxGUIAppTraits::AfterChildWaitLoop(void *dataOrig)
 183 {
 184     wxEndBusyCursor();
 185
 186     ChildWaitLoopData * const data = (ChildWaitLoopData *)dataOrig;
 187
 188     delete data->wd;
 189
 190     // finally delete the dummy frame and, as wd has been already destroyed and
 191     // the other windows reenabled, the activation is going to return to the
 192     // window which had had it before
 193     data->winActive->Destroy();
 194
 195     // also delete the temporary data object itself
 196     delete data;
 197 }
 198
 199 bool wxGUIAppTraits::DoMessageFromThreadWait()
 200 {
 201     // we should return false only if the app should exit, i.e. only if
 202     // Dispatch() determines that the main event loop should terminate
 203     return !wxTheApp || wxTheApp->Dispatch();
 204 }
 205
 206 wxToolkitInfo& wxGUIAppTraits::GetToolkitInfo()
 207 {
 208     static wxToolkitInfo info;
 209     wxToolkitInfo& baseInfo = wxAppTraits::GetToolkitInfo();
 210     info.versionMajor = baseInfo.versionMajor;
 211     info.versionMinor = baseInfo.versionMinor;
 212     info.os = baseInfo.os;
 213     info.shortName = _T("msw");
 214     info.name = _T("wxMSW");
 215 #ifdef __WXUNIVERSAL__
 216     info.shortName << _T("univ");
 217     info.name << _T("/wxUniversal");
 218 #endif
 219     return info;
 220 }
 221
 222 // ===========================================================================
 223 // wxApp implementation
 224 // ===========================================================================
 225
 226 int wxApp::m_nCmdShow = SW_SHOWNORMAL;
 227
 228 // ---------------------------------------------------------------------------
 229 // wxWin macros
 230 // ---------------------------------------------------------------------------
 231
 232 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
 233
 234 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 235     EVT_IDLE(wxApp::OnIdle)
 236     EVT_END_SESSION(wxApp::OnEndSession)
 237     EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
 238 END_EVENT_TABLE()
 239
 240 // class to ensure that wxAppBase::CleanUp() is called if our Initialize()
 241 // fails
 242 class wxCallBaseCleanup
 243 {
 244 public:
 245     wxCallBaseCleanup(wxApp *app) : m_app(app) { }
 246     ~wxCallBaseCleanup() { if ( m_app ) m_app->wxAppBase::CleanUp(); }
 247
 248     void Dismiss() { m_app = NULL; }
 249
 250 private:
 251     wxApp *m_app;
 252 };
 253
 254 //// Initialize
 255 bool wxApp::Initialize(int& argc, wxChar **argv)
 256 {
 257     if ( !wxAppBase::Initialize(argc, argv) )
 258         return false;
 259
 260     // ensure that base cleanup is done if we return too early
 261     wxCallBaseCleanup callBaseCleanup(this);
 262
 263 #ifdef __WXWINCE__
 264     wxString tmp = GetAppName();
 265     tmp += wxT("ClassName");
 266     wxCanvasClassName = wxStrdup( tmp.c_str() );
 267     tmp += wxT("NR");
 268     wxCanvasClassNameNR = wxStrdup( tmp.c_str() );
 269     HWND hWnd = FindWindow( wxCanvasClassNameNR, NULL );
 270     if (hWnd)
 271     {
 272         SetForegroundWindow( (HWND)(((DWORD)hWnd)|0x01) );
 273         return false;
 274     }
 275 #endif
 276
 277     // the first thing to do is to check if we're trying to run an Unicode
 278     // program under Win9x w/o MSLU emulation layer - if so, abort right now
 279     // as it has no chance to work
 280 #if wxUSE_UNICODE && !wxUSE_UNICODE_MSLU
 281     if ( wxGetOsVersion() != wxWINDOWS_NT && wxGetOsVersion() != wxWINDOWS_CE )
 282     {
 283         // note that we can use MessageBoxW() as it's implemented even under
 284         // Win9x - OTOH, we can't use wxGetTranslation() because the file APIs
 285         // used by wxLocale are not
 286         ::MessageBox
 287         (
 288          NULL,
 289          _T("This program uses Unicode and requires Windows NT/2000/XP/CE.\nProgram aborted."),
 290          _T("wxWidgets Fatal Error"),
 291          MB_ICONERROR | MB_OK
 292         );
 293
 294         return false;
 295     }
 296 #endif // wxUSE_UNICODE && !wxUSE_UNICODE_MSLU
 297
 298 #if defined(__WIN95__) && !defined(__WXMICROWIN__)
 299     InitCommonControls();
 300 #endif // __WIN95__
 301
 302 #if wxUSE_OLE || wxUSE_DRAG_AND_DROP
 303
 304 #if wxUSE_OLE
 305     // we need to initialize OLE library
 306 #ifdef __WXWINCE__
 307     if ( FAILED(::CoInitializeEx(NULL, COINIT_MULTITHREADED)) )
 308         wxLogError(_("Cannot initialize OLE"));
 309 #else
 310     if ( FAILED(::OleInitialize(NULL)) )
 311         wxLogError(_("Cannot initialize OLE"));
 312 #endif
 313 #endif
 314
 315 #endif // wxUSE_OLE
 316
 317     RegisterWindowClasses();
 318
 319 #if wxUSE_PENWINDOWS
 320     wxRegisterPenWin();
 321 #endif
 322
 323     wxWinHandleHash = new wxWinHashTable(wxKEY_INTEGER, 100);
 324
 325 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 326     wxSetKeyboardHook(true);
 327 #endif
 328
 329     callBaseCleanup.Dismiss();
 330
 331     return true;
 332 }
 333
 334 // ---------------------------------------------------------------------------
 335 // RegisterWindowClasses
 336 // ---------------------------------------------------------------------------
 337
 338 // TODO we should only register classes really used by the app. For this it
 339 //      would be enough to just delay the class registration until an attempt
 340 //      to create a window of this class is made.
 341 bool wxApp::RegisterWindowClasses()
 342 {
 343     WNDCLASS wndclass;
 344     wxZeroMemory(wndclass);
 345
 346     // for each class we register one with CS_(V|H)REDRAW style and one
 347     // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
 348     static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
 349     static const long styleNoRedraw = CS_DBLCLKS;
 350
 351     // the fields which are common to all classes
 352     wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
 353     wndclass.hInstance     = wxhInstance;
 354     wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
 355
 356     // register the class for all normal windows
 357     wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
 358     wndclass.lpszClassName = wxCanvasClassName;
 359     wndclass.style         = styleNormal;
 360
 361     if ( !RegisterClass(&wndclass) )
 362     {
 363         wxLogLastError(wxT("RegisterClass(frame)"));
 364     }
 365
 366     // "no redraw" frame
 367     wndclass.lpszClassName = wxCanvasClassNameNR;
 368     wndclass.style         = styleNoRedraw;
 369
 370     if ( !RegisterClass(&wndclass) )
 371     {
 372         wxLogLastError(wxT("RegisterClass(no redraw frame)"));
 373     }
 374
 375     // Register the MDI frame window class.
 376     wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
 377     wndclass.lpszClassName = wxMDIFrameClassName;
 378     wndclass.style         = styleNormal;
 379
 380     if ( !RegisterClass(&wndclass) )
 381     {
 382         wxLogLastError(wxT("RegisterClass(MDI parent)"));
 383     }
 384
 385     // "no redraw" MDI frame
 386     wndclass.lpszClassName = wxMDIFrameClassNameNoRedraw;
 387     wndclass.style         = styleNoRedraw;
 388
 389     if ( !RegisterClass(&wndclass) )
 390     {
 391         wxLogLastError(wxT("RegisterClass(no redraw MDI parent frame)"));
 392     }
 393
 394     // Register the MDI child frame window class.
 395     wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
 396     wndclass.lpszClassName = wxMDIChildFrameClassName;
 397     wndclass.style         = styleNormal;
 398
 399     if ( !RegisterClass(&wndclass) )
 400     {
 401         wxLogLastError(wxT("RegisterClass(MDI child)"));
 402     }
 403
 404     // "no redraw" MDI child frame
 405     wndclass.lpszClassName = wxMDIChildFrameClassNameNoRedraw;
 406     wndclass.style         = styleNoRedraw;
 407
 408     if ( !RegisterClass(&wndclass) )
 409     {
 410         wxLogLastError(wxT("RegisterClass(no redraw MDI child)"));
 411     }
 412
 413     return true;
 414 }
 415
 416 // ---------------------------------------------------------------------------
 417 // UnregisterWindowClasses
 418 // ---------------------------------------------------------------------------
 419
 420 bool wxApp::UnregisterWindowClasses()
 421 {
 422     bool retval = true;
 423
 424 #ifndef __WXMICROWIN__
 425     // MDI frame window class.
 426     if ( !::UnregisterClass(wxMDIFrameClassName, wxhInstance) )
 427     {
 428         wxLogLastError(wxT("UnregisterClass(MDI parent)"));
 429
 430         retval = false;
 431     }
 432
 433     // "no redraw" MDI frame
 434     if ( !::UnregisterClass(wxMDIFrameClassNameNoRedraw, wxhInstance) )
 435     {
 436         wxLogLastError(wxT("UnregisterClass(no redraw MDI parent frame)"));
 437
 438         retval = false;
 439     }
 440
 441     // MDI child frame window class.
 442     if ( !::UnregisterClass(wxMDIChildFrameClassName, wxhInstance) )
 443     {
 444         wxLogLastError(wxT("UnregisterClass(MDI child)"));
 445
 446         retval = false;
 447     }
 448
 449     // "no redraw" MDI child frame
 450     if ( !::UnregisterClass(wxMDIChildFrameClassNameNoRedraw, wxhInstance) )
 451     {
 452         wxLogLastError(wxT("UnregisterClass(no redraw MDI child)"));
 453
 454         retval = false;
 455     }
 456
 457     // canvas class name
 458     if ( !::UnregisterClass(wxCanvasClassName, wxhInstance) )
 459     {
 460         wxLogLastError(wxT("UnregisterClass(canvas)"));
 461
 462         retval = false;
 463     }
 464
 465     if ( !::UnregisterClass(wxCanvasClassNameNR, wxhInstance) )
 466     {
 467         wxLogLastError(wxT("UnregisterClass(no redraw canvas)"));
 468
 469         retval = false;
 470     }
 471 #endif // __WXMICROWIN__
 472
 473     return retval;
 474 }
 475
 476 void wxApp::CleanUp()
 477 {
 478     // all objects pending for deletion must be deleted first, otherwise we
 479     // would crash when they use wxWinHandleHash (and UnregisterWindowClasses()
 480     // call wouldn't succeed as long as any windows still exist), so call the
 481     // base class method first and only then do our clean up
 482     wxAppBase::CleanUp();
 483
 484 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 485     wxSetKeyboardHook(false);
 486 #endif
 487
 488 #if wxUSE_PENWINDOWS
 489     wxCleanUpPenWin();
 490 #endif
 491
 492 #if wxUSE_OLE
 493 #ifdef __WXWINCE__
 494     ::CoUninitialize();
 495 #else
 496     ::OleUninitialize();
 497 #endif
 498 #endif
 499
 500     // for an EXE the classes are unregistered when it terminates but DLL may
 501     // be loaded several times (load/unload/load) into the same process in
 502     // which case the registration will fail after the first time if we don't
 503     // unregister the classes now
 504     UnregisterWindowClasses();
 505
 506     delete wxWinHandleHash;
 507     wxWinHandleHash = NULL;
 508
 509 #ifdef __WXWINCE__
 510     free( wxCanvasClassName );
 511     free( wxCanvasClassNameNR );
 512 #endif
 513 }
 514
 515 // ----------------------------------------------------------------------------
 516 // wxApp ctor/dtor
 517 // ----------------------------------------------------------------------------
 518
 519 wxApp::wxApp()
 520 {
 521     m_printMode = wxPRINT_WINDOWS;
 522 }
 523
 524 wxApp::~wxApp()
 525 {
 526     // our cmd line arguments are allocated inside wxEntry(HINSTANCE), they
 527     // don't come from main(), so we have to free them
 528
 529     while ( argc )
 530     {
 531         // m_argv elements were allocated by wxStrdup()
 532         free(argv[--argc]);
 533     }
 534
 535     // but m_argv itself -- using new[]
 536     delete [] argv;
 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         // do we have it?
 619         wxDynamicLibrary dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM);
 620
 621         // if so, then we can check for the version
 622         if ( dllComCtl32.IsLoaded() )
 623         {
 624 #ifdef DLLVER_PLATFORM_WINDOWS
 625             // try to use DllGetVersion() if available in _headers_
 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 #endif
 647
 648             // if DllGetVersion() is unavailable either during compile or
 649             // run-time, try to guess the version otherwise
 650             if ( !s_verComCtl32 )
 651             {
 652                 // InitCommonControlsEx is unique to 4.70 and later
 653                 void *pfn = dllComCtl32.GetSymbol(_T("InitCommonControlsEx"));
 654                 if ( !pfn )
 655                 {
 656                     // not found, must be 4.00
 657                     s_verComCtl32 = 400;
 658                 }
 659                 else // 4.70+
 660                 {
 661                     // many symbols appeared in comctl32 4.71, could use any of
 662                     // them except may be DllInstall()
 663                     pfn = dllComCtl32.GetSymbol(_T("InitializeFlatSB"));
 664                     if ( !pfn )
 665                     {
 666                         // not found, must be 4.70
 667                         s_verComCtl32 = 470;
 668                     }
 669                     else
 670                     {
 671                         // found, must be 4.71 or later
 672                         s_verComCtl32 = 471;
 673                     }
 674                 }
 675             }
 676         }
 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 #include "wx/evtloop.h"
 783
 784 void wxApp::DoMessage(WXMSG *pMsg)
 785 {
 786     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 787     if ( evtLoop )
 788         evtLoop->ProcessMessage(pMsg);
 789 }
 790
 791 bool wxApp::DoMessage()
 792 {
 793     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 794     return evtLoop ? evtLoop->Dispatch() : false;
 795 }
 796
 797 bool wxApp::ProcessMessage(WXMSG* pMsg)
 798 {
 799     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 800     return evtLoop && evtLoop->PreProcessMessage(pMsg);
 801 }
 802
 803 #endif // WXWIN_COMPATIBILITY_2_4
 804