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