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     wxOleInitialize();
 304
 305     RegisterWindowClasses();
 306
 307     wxWinHandleHash = new wxWinHashTable(wxKEY_INTEGER, 100);
 308
 309 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 310     wxSetKeyboardHook(true);
 311 #endif
 312
 313     callBaseCleanup.Dismiss();
 314
 315     return true;
 316 }
 317
 318 // ---------------------------------------------------------------------------
 319 // RegisterWindowClasses
 320 // ---------------------------------------------------------------------------
 321
 322 // TODO we should only register classes really used by the app. For this it
 323 //      would be enough to just delay the class registration until an attempt
 324 //      to create a window of this class is made.
 325 bool wxApp::RegisterWindowClasses()
 326 {
 327     WNDCLASS wndclass;
 328     wxZeroMemory(wndclass);
 329
 330     // for each class we register one with CS_(V|H)REDRAW style and one
 331     // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
 332     static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
 333     static const long styleNoRedraw = CS_DBLCLKS;
 334
 335     // the fields which are common to all classes
 336     wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
 337     wndclass.hInstance     = wxhInstance;
 338     wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
 339
 340     // register the class for all normal windows
 341     wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
 342     wndclass.lpszClassName = wxCanvasClassName;
 343     wndclass.style         = styleNormal;
 344
 345     if ( !RegisterClass(&wndclass) )
 346     {
 347         wxLogLastError(wxT("RegisterClass(frame)"));
 348     }
 349
 350     // "no redraw" frame
 351     wndclass.lpszClassName = wxCanvasClassNameNR;
 352     wndclass.style         = styleNoRedraw;
 353
 354     if ( !RegisterClass(&wndclass) )
 355     {
 356         wxLogLastError(wxT("RegisterClass(no redraw frame)"));
 357     }
 358
 359     // Register the MDI frame window class.
 360     wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
 361     wndclass.lpszClassName = wxMDIFrameClassName;
 362     wndclass.style         = styleNormal;
 363
 364     if ( !RegisterClass(&wndclass) )
 365     {
 366         wxLogLastError(wxT("RegisterClass(MDI parent)"));
 367     }
 368
 369     // "no redraw" MDI frame
 370     wndclass.lpszClassName = wxMDIFrameClassNameNoRedraw;
 371     wndclass.style         = styleNoRedraw;
 372
 373     if ( !RegisterClass(&wndclass) )
 374     {
 375         wxLogLastError(wxT("RegisterClass(no redraw MDI parent frame)"));
 376     }
 377
 378     // Register the MDI child frame window class.
 379     wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
 380     wndclass.lpszClassName = wxMDIChildFrameClassName;
 381     wndclass.style         = styleNormal;
 382
 383     if ( !RegisterClass(&wndclass) )
 384     {
 385         wxLogLastError(wxT("RegisterClass(MDI child)"));
 386     }
 387
 388     // "no redraw" MDI child frame
 389     wndclass.lpszClassName = wxMDIChildFrameClassNameNoRedraw;
 390     wndclass.style         = styleNoRedraw;
 391
 392     if ( !RegisterClass(&wndclass) )
 393     {
 394         wxLogLastError(wxT("RegisterClass(no redraw MDI child)"));
 395     }
 396
 397     return true;
 398 }
 399
 400 // ---------------------------------------------------------------------------
 401 // UnregisterWindowClasses
 402 // ---------------------------------------------------------------------------
 403
 404 bool wxApp::UnregisterWindowClasses()
 405 {
 406     bool retval = true;
 407
 408 #ifndef __WXMICROWIN__
 409     // MDI frame window class.
 410     if ( !::UnregisterClass(wxMDIFrameClassName, wxhInstance) )
 411     {
 412         wxLogLastError(wxT("UnregisterClass(MDI parent)"));
 413
 414         retval = false;
 415     }
 416
 417     // "no redraw" MDI frame
 418     if ( !::UnregisterClass(wxMDIFrameClassNameNoRedraw, wxhInstance) )
 419     {
 420         wxLogLastError(wxT("UnregisterClass(no redraw MDI parent frame)"));
 421
 422         retval = false;
 423     }
 424
 425     // MDI child frame window class.
 426     if ( !::UnregisterClass(wxMDIChildFrameClassName, wxhInstance) )
 427     {
 428         wxLogLastError(wxT("UnregisterClass(MDI child)"));
 429
 430         retval = false;
 431     }
 432
 433     // "no redraw" MDI child frame
 434     if ( !::UnregisterClass(wxMDIChildFrameClassNameNoRedraw, wxhInstance) )
 435     {
 436         wxLogLastError(wxT("UnregisterClass(no redraw MDI child)"));
 437
 438         retval = false;
 439     }
 440
 441     // canvas class name
 442     if ( !::UnregisterClass(wxCanvasClassName, wxhInstance) )
 443     {
 444         wxLogLastError(wxT("UnregisterClass(canvas)"));
 445
 446         retval = false;
 447     }
 448
 449     if ( !::UnregisterClass(wxCanvasClassNameNR, wxhInstance) )
 450     {
 451         wxLogLastError(wxT("UnregisterClass(no redraw canvas)"));
 452
 453         retval = false;
 454     }
 455 #endif // __WXMICROWIN__
 456
 457     return retval;
 458 }
 459
 460 void wxApp::CleanUp()
 461 {
 462     // all objects pending for deletion must be deleted first, otherwise we
 463     // would crash when they use wxWinHandleHash (and UnregisterWindowClasses()
 464     // call wouldn't succeed as long as any windows still exist), so call the
 465     // base class method first and only then do our clean up
 466     wxAppBase::CleanUp();
 467
 468 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 469     wxSetKeyboardHook(false);
 470 #endif
 471
 472     wxOleUninitialize();
 473
 474     // for an EXE the classes are unregistered when it terminates but DLL may
 475     // be loaded several times (load/unload/load) into the same process in
 476     // which case the registration will fail after the first time if we don't
 477     // unregister the classes now
 478     UnregisterWindowClasses();
 479
 480     delete wxWinHandleHash;
 481     wxWinHandleHash = NULL;
 482
 483 #ifdef __WXWINCE__
 484     free( wxCanvasClassName );
 485     free( wxCanvasClassNameNR );
 486 #endif
 487 }
 488
 489 // ----------------------------------------------------------------------------
 490 // wxApp ctor/dtor
 491 // ----------------------------------------------------------------------------
 492
 493 wxApp::wxApp()
 494 {
 495     m_printMode = wxPRINT_WINDOWS;
 496 }
 497
 498 wxApp::~wxApp()
 499 {
 500     // our cmd line arguments are allocated inside wxEntry(HINSTANCE), they
 501     // don't come from main(), so we have to free them
 502
 503     while ( argc )
 504     {
 505         // m_argv elements were allocated by wxStrdup()
 506         free(argv[--argc]);
 507     }
 508
 509     // but m_argv itself -- using new[]
 510     delete [] argv;
 511 }
 512
 513 // ----------------------------------------------------------------------------
 514 // wxApp idle handling
 515 // ----------------------------------------------------------------------------
 516
 517 void wxApp::OnIdle(wxIdleEvent& event)
 518 {
 519     wxAppBase::OnIdle(event);
 520
 521 #if wxUSE_DC_CACHEING
 522     // automated DC cache management: clear the cached DCs and bitmap
 523     // if it's likely that the app has finished with them, that is, we
 524     // get an idle event and we're not dragging anything.
 525     if (!::GetKeyState(MK_LBUTTON) && !::GetKeyState(MK_MBUTTON) && !::GetKeyState(MK_RBUTTON))
 526         wxDC::ClearCache();
 527 #endif // wxUSE_DC_CACHEING
 528 }
 529
 530 void wxApp::WakeUpIdle()
 531 {
 532     // Send the top window a dummy message so idle handler processing will
 533     // start up again.  Doing it this way ensures that the idle handler
 534     // wakes up in the right thread (see also wxWakeUpMainThread() which does
 535     // the same for the main app thread only)
 536     wxWindow *topWindow = wxTheApp->GetTopWindow();
 537     if ( topWindow )
 538     {
 539         if ( !::PostMessage(GetHwndOf(topWindow), WM_NULL, 0, 0) )
 540         {
 541             // should never happen
 542             wxLogLastError(wxT("PostMessage(WM_NULL)"));
 543         }
 544     }
 545 }
 546
 547 // ----------------------------------------------------------------------------
 548 // other wxApp event hanlders
 549 // ----------------------------------------------------------------------------
 550
 551 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
 552 {
 553     if (GetTopWindow())
 554         GetTopWindow()->Close(true);
 555 }
 556
 557 // Default behaviour: close the application with prompts. The
 558 // user can veto the close, and therefore the end session.
 559 void wxApp::OnQueryEndSession(wxCloseEvent& event)
 560 {
 561     if (GetTopWindow())
 562     {
 563         if (!GetTopWindow()->Close(!event.CanVeto()))
 564             event.Veto(true);
 565     }
 566 }
 567
 568 // ----------------------------------------------------------------------------
 569 // miscellaneous
 570 // ----------------------------------------------------------------------------
 571
 572 /* static */
 573 int wxApp::GetComCtl32Version()
 574 {
 575 #if defined(__WXMICROWIN__) || defined(__WXWINCE__)
 576     return 0;
 577 #else
 578     // cache the result
 579     //
 580     // NB: this is MT-ok as in the worst case we'd compute s_verComCtl32 twice,
 581     //     but as its value should be the same both times it doesn't matter
 582     static int s_verComCtl32 = -1;
 583
 584     if ( s_verComCtl32 == -1 )
 585     {
 586         // initally assume no comctl32.dll at all
 587         s_verComCtl32 = 0;
 588
 589         // we're prepared to handle the errors
 590         wxLogNull noLog;
 591
 592         // do we have it?
 593         wxDynamicLibrary dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM);
 594
 595         // if so, then we can check for the version
 596         if ( dllComCtl32.IsLoaded() )
 597         {
 598             // now check if the function is available during run-time
 599             wxDYNLIB_FUNCTION( DLLGETVERSIONPROC, DllGetVersion, dllComCtl32 );
 600             if ( pfnDllGetVersion )
 601             {
 602                 DLLVERSIONINFO dvi;
 603                 dvi.cbSize = sizeof(dvi);
 604
 605                 HRESULT hr = (*pfnDllGetVersion)(&dvi);
 606                 if ( FAILED(hr) )
 607                 {
 608                     wxLogApiError(_T("DllGetVersion"), hr);
 609                 }
 610                 else
 611                 {
 612                     // this is incompatible with _WIN32_IE values, but
 613                     // compatible with the other values returned by
 614                     // GetComCtl32Version()
 615                     s_verComCtl32 = 100*dvi.dwMajorVersion +
 616                                         dvi.dwMinorVersion;
 617                 }
 618             }
 619
 620             // if DllGetVersion() is unavailable either during compile or
 621             // run-time, try to guess the version otherwise
 622             if ( !s_verComCtl32 )
 623             {
 624                 // InitCommonControlsEx is unique to 4.70 and later
 625                 void *pfn = dllComCtl32.GetSymbol(_T("InitCommonControlsEx"));
 626                 if ( !pfn )
 627                 {
 628                     // not found, must be 4.00
 629                     s_verComCtl32 = 400;
 630                 }
 631                 else // 4.70+
 632                 {
 633                     // many symbols appeared in comctl32 4.71, could use any of
 634                     // them except may be DllInstall()
 635                     pfn = dllComCtl32.GetSymbol(_T("InitializeFlatSB"));
 636                     if ( !pfn )
 637                     {
 638                         // not found, must be 4.70
 639                         s_verComCtl32 = 470;
 640                     }
 641                     else
 642                     {
 643                         // found, must be 4.71 or later
 644                         s_verComCtl32 = 471;
 645                     }
 646                 }
 647             }
 648         }
 649     }
 650
 651     return s_verComCtl32;
 652 #endif // Microwin/!Microwin
 653 }
 654
 655 // Yield to incoming messages
 656
 657 bool wxApp::Yield(bool onlyIfNeeded)
 658 {
 659     // MT-FIXME
 660     static bool s_inYield = false;
 661
 662 #if wxUSE_LOG
 663     // disable log flushing from here because a call to wxYield() shouldn't
 664     // normally result in message boxes popping up &c
 665     wxLog::Suspend();
 666 #endif // wxUSE_LOG
 667
 668     if ( s_inYield )
 669     {
 670         if ( !onlyIfNeeded )
 671         {
 672             wxFAIL_MSG( wxT("wxYield called recursively" ) );
 673         }
 674
 675         return false;
 676     }
 677
 678     s_inYield = true;
 679
 680     // we don't want to process WM_QUIT from here - it should be processed in
 681     // the main event loop in order to stop it
 682     MSG msg;
 683     while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) &&
 684             msg.message != WM_QUIT )
 685     {
 686 #if wxUSE_THREADS
 687         wxMutexGuiLeaveOrEnter();
 688 #endif // wxUSE_THREADS
 689
 690         if ( !wxTheApp->Dispatch() )
 691             break;
 692     }
 693
 694     // if there are pending events, we must process them.
 695     ProcessPendingEvents();
 696
 697 #if wxUSE_LOG
 698     // let the logs be flashed again
 699     wxLog::Resume();
 700 #endif // wxUSE_LOG
 701
 702     s_inYield = false;
 703
 704     return true;
 705 }
 706
 707 #if wxUSE_EXCEPTIONS
 708
 709 // ----------------------------------------------------------------------------
 710 // exception handling
 711 // ----------------------------------------------------------------------------
 712
 713 bool wxApp::OnExceptionInMainLoop()
 714 {
 715     // ask the user about what to do: use the Win32 API function here as it
 716     // could be dangerous to use any wxWidgets code in this state
 717     switch (
 718             ::MessageBox
 719               (
 720                 NULL,
 721                 _T("An unhandled exception occurred. Press \"Abort\" to \
 722 terminate the program,\r\n\
 723 \"Retry\" to exit the program normally and \"Ignore\" to try to continue."),
 724                 _T("Unhandled exception"),
 725                 MB_ABORTRETRYIGNORE |
 726                 MB_ICONERROR|
 727                 MB_TASKMODAL
 728               )
 729            )
 730     {
 731         case IDABORT:
 732             throw;
 733
 734         default:
 735             wxFAIL_MSG( _T("unexpected MessageBox() return code") );
 736             // fall through
 737
 738         case IDRETRY:
 739             return false;
 740
 741         case IDIGNORE:
 742             return true;
 743     }
 744 }
 745
 746 #endif // wxUSE_EXCEPTIONS
 747
 748 // ----------------------------------------------------------------------------
 749 // deprecated event loop functions
 750 // ----------------------------------------------------------------------------
 751
 752 #if WXWIN_COMPATIBILITY_2_4
 753
 754 #include "wx/evtloop.h"
 755
 756 void wxApp::DoMessage(WXMSG *pMsg)
 757 {
 758     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 759     if ( evtLoop )
 760         evtLoop->ProcessMessage(pMsg);
 761 }
 762
 763 bool wxApp::DoMessage()
 764 {
 765     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 766     return evtLoop ? evtLoop->Dispatch() : false;
 767 }
 768
 769 bool wxApp::ProcessMessage(WXMSG* pMsg)
 770 {
 771     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 772     return evtLoop && evtLoop->PreProcessMessage(pMsg);
 773 }
 774
 775 #endif // WXWIN_COMPATIBILITY_2_4