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 }
 507
 508 // ----------------------------------------------------------------------------
 509 // wxApp idle handling
 510 // ----------------------------------------------------------------------------
 511
 512 void wxApp::OnIdle(wxIdleEvent& event)
 513 {
 514     wxAppBase::OnIdle(event);
 515
 516 #if wxUSE_DC_CACHEING
 517     // automated DC cache management: clear the cached DCs and bitmap
 518     // if it's likely that the app has finished with them, that is, we
 519     // get an idle event and we're not dragging anything.
 520     if (!::GetKeyState(MK_LBUTTON) && !::GetKeyState(MK_MBUTTON) && !::GetKeyState(MK_RBUTTON))
 521         wxDC::ClearCache();
 522 #endif // wxUSE_DC_CACHEING
 523 }
 524
 525 void wxApp::WakeUpIdle()
 526 {
 527     // Send the top window a dummy message so idle handler processing will
 528     // start up again.  Doing it this way ensures that the idle handler
 529     // wakes up in the right thread (see also wxWakeUpMainThread() which does
 530     // the same for the main app thread only)
 531     wxWindow *topWindow = wxTheApp->GetTopWindow();
 532     if ( topWindow )
 533     {
 534         if ( !::PostMessage(GetHwndOf(topWindow), WM_NULL, 0, 0) )
 535         {
 536             // should never happen
 537             wxLogLastError(wxT("PostMessage(WM_NULL)"));
 538         }
 539     }
 540 }
 541
 542 // ----------------------------------------------------------------------------
 543 // other wxApp event hanlders
 544 // ----------------------------------------------------------------------------
 545
 546 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
 547 {
 548     if (GetTopWindow())
 549         GetTopWindow()->Close(true);
 550 }
 551
 552 // Default behaviour: close the application with prompts. The
 553 // user can veto the close, and therefore the end session.
 554 void wxApp::OnQueryEndSession(wxCloseEvent& event)
 555 {
 556     if (GetTopWindow())
 557     {
 558         if (!GetTopWindow()->Close(!event.CanVeto()))
 559             event.Veto(true);
 560     }
 561 }
 562
 563 // ----------------------------------------------------------------------------
 564 // miscellaneous
 565 // ----------------------------------------------------------------------------
 566
 567 /* static */
 568 int wxApp::GetComCtl32Version()
 569 {
 570 #if defined(__WXMICROWIN__) || defined(__WXWINCE__)
 571     return 0;
 572 #else
 573     // cache the result
 574     //
 575     // NB: this is MT-ok as in the worst case we'd compute s_verComCtl32 twice,
 576     //     but as its value should be the same both times it doesn't matter
 577     static int s_verComCtl32 = -1;
 578
 579     if ( s_verComCtl32 == -1 )
 580     {
 581         // initally assume no comctl32.dll at all
 582         s_verComCtl32 = 0;
 583
 584         // we're prepared to handle the errors
 585         wxLogNull noLog;
 586
 587 #if wxUSE_DYNLIB_CLASS
 588         // do we have it?
 589         wxDynamicLibrary dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM);
 590
 591         // if so, then we can check for the version
 592         if ( dllComCtl32.IsLoaded() )
 593         {
 594             // now check if the function is available during run-time
 595             wxDYNLIB_FUNCTION( DLLGETVERSIONPROC, DllGetVersion, dllComCtl32 );
 596             if ( pfnDllGetVersion )
 597             {
 598                 DLLVERSIONINFO dvi;
 599                 dvi.cbSize = sizeof(dvi);
 600
 601                 HRESULT hr = (*pfnDllGetVersion)(&dvi);
 602                 if ( FAILED(hr) )
 603                 {
 604                     wxLogApiError(_T("DllGetVersion"), hr);
 605                 }
 606                 else
 607                 {
 608                     // this is incompatible with _WIN32_IE values, but
 609                     // compatible with the other values returned by
 610                     // GetComCtl32Version()
 611                     s_verComCtl32 = 100*dvi.dwMajorVersion +
 612                                         dvi.dwMinorVersion;
 613                 }
 614             }
 615
 616             // if DllGetVersion() is unavailable either during compile or
 617             // run-time, try to guess the version otherwise
 618             if ( !s_verComCtl32 )
 619             {
 620                 // InitCommonControlsEx is unique to 4.70 and later
 621                 void *pfn = dllComCtl32.GetSymbol(_T("InitCommonControlsEx"));
 622                 if ( !pfn )
 623                 {
 624                     // not found, must be 4.00
 625                     s_verComCtl32 = 400;
 626                 }
 627                 else // 4.70+
 628                 {
 629                     // many symbols appeared in comctl32 4.71, could use any of
 630                     // them except may be DllInstall()
 631                     pfn = dllComCtl32.GetSymbol(_T("InitializeFlatSB"));
 632                     if ( !pfn )
 633                     {
 634                         // not found, must be 4.70
 635                         s_verComCtl32 = 470;
 636                     }
 637                     else
 638                     {
 639                         // found, must be 4.71 or later
 640                         s_verComCtl32 = 471;
 641                     }
 642                 }
 643             }
 644         }
 645 #endif
 646     }
 647
 648     return s_verComCtl32;
 649 #endif // Microwin/!Microwin
 650 }
 651
 652 // Yield to incoming messages
 653
 654 bool wxApp::Yield(bool onlyIfNeeded)
 655 {
 656     // MT-FIXME
 657     static bool s_inYield = false;
 658
 659 #if wxUSE_LOG
 660     // disable log flushing from here because a call to wxYield() shouldn't
 661     // normally result in message boxes popping up &c
 662     wxLog::Suspend();
 663 #endif // wxUSE_LOG
 664
 665     if ( s_inYield )
 666     {
 667         if ( !onlyIfNeeded )
 668         {
 669             wxFAIL_MSG( wxT("wxYield called recursively" ) );
 670         }
 671
 672         return false;
 673     }
 674
 675     s_inYield = true;
 676
 677     // we don't want to process WM_QUIT from here - it should be processed in
 678     // the main event loop in order to stop it
 679     MSG msg;
 680     while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) &&
 681             msg.message != WM_QUIT )
 682     {
 683 #if wxUSE_THREADS
 684         wxMutexGuiLeaveOrEnter();
 685 #endif // wxUSE_THREADS
 686
 687         if ( !wxTheApp->Dispatch() )
 688             break;
 689     }
 690
 691     // if there are pending events, we must process them.
 692     ProcessPendingEvents();
 693
 694 #if wxUSE_LOG
 695     // let the logs be flashed again
 696     wxLog::Resume();
 697 #endif // wxUSE_LOG
 698
 699     s_inYield = false;
 700
 701     return true;
 702 }
 703
 704 #if wxUSE_EXCEPTIONS
 705
 706 // ----------------------------------------------------------------------------
 707 // exception handling
 708 // ----------------------------------------------------------------------------
 709
 710 bool wxApp::OnExceptionInMainLoop()
 711 {
 712     // ask the user about what to do: use the Win32 API function here as it
 713     // could be dangerous to use any wxWidgets code in this state
 714     switch (
 715             ::MessageBox
 716               (
 717                 NULL,
 718                 _T("An unhandled exception occurred. Press \"Abort\" to \
 719 terminate the program,\r\n\
 720 \"Retry\" to exit the program normally and \"Ignore\" to try to continue."),
 721                 _T("Unhandled exception"),
 722                 MB_ABORTRETRYIGNORE |
 723                 MB_ICONERROR|
 724                 MB_TASKMODAL
 725               )
 726            )
 727     {
 728         case IDABORT:
 729             throw;
 730
 731         default:
 732             wxFAIL_MSG( _T("unexpected MessageBox() return code") );
 733             // fall through
 734
 735         case IDRETRY:
 736             return false;
 737
 738         case IDIGNORE:
 739             return true;
 740     }
 741 }
 742
 743 #endif // wxUSE_EXCEPTIONS
 744
 745 // ----------------------------------------------------------------------------
 746 // deprecated event loop functions
 747 // ----------------------------------------------------------------------------
 748
 749 #if WXWIN_COMPATIBILITY_2_4
 750
 751 #include "wx/evtloop.h"
 752
 753 void wxApp::DoMessage(WXMSG *pMsg)
 754 {
 755     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 756     if ( evtLoop )
 757         evtLoop->ProcessMessage(pMsg);
 758 }
 759
 760 bool wxApp::DoMessage()
 761 {
 762     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 763     return evtLoop ? evtLoop->Dispatch() : false;
 764 }
 765
 766 bool wxApp::ProcessMessage(WXMSG* pMsg)
 767 {
 768     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 769     return evtLoop && evtLoop->PreProcessMessage(pMsg);
 770 }
 771
 772 #endif // WXWIN_COMPATIBILITY_2_4