src/msw/app.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/app.cpp
   3 // Purpose:     wxApp
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ===========================================================================
  13 // declarations
  14 // ===========================================================================
  15
  16 // ---------------------------------------------------------------------------
  17 // headers
  18 // ---------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #if defined(__BORLANDC__)
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/msw/wrapcctl.h"
  29     #include "wx/dynarray.h"
  30     #include "wx/frame.h"
  31     #include "wx/app.h"
  32     #include "wx/utils.h"
  33     #include "wx/gdicmn.h"
  34     #include "wx/pen.h"
  35     #include "wx/brush.h"
  36     #include "wx/cursor.h"
  37     #include "wx/icon.h"
  38     #include "wx/palette.h"
  39     #include "wx/dc.h"
  40     #include "wx/dialog.h"
  41     #include "wx/msgdlg.h"
  42     #include "wx/intl.h"
  43     #include "wx/wxchar.h"
  44     #include "wx/log.h"
  45     #include "wx/module.h"
  46 #endif
  47
  48 #include "wx/apptrait.h"
  49 #include "wx/filename.h"
  50 #include "wx/dynlib.h"
  51 #include "wx/evtloop.h"
  52
  53 #include "wx/msw/private.h"
  54 #include "wx/msw/ole/oleutils.h"
  55
  56 #if wxUSE_TOOLTIPS
  57     #include "wx/tooltip.h"
  58 #endif // wxUSE_TOOLTIPS
  59
  60 // OLE is used for drag-and-drop, clipboard, OLE Automation..., but some
  61 // compilers don't support it (missing headers, libs, ...)
  62 #if defined(__GNUWIN32_OLD__) || defined(__SYMANTEC__) || defined(__SALFORDC__)
  63     #undef wxUSE_OLE
  64
  65     #define  wxUSE_OLE 0
  66 #endif // broken compilers
  67
  68 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
  69     #include <ole2.h>
  70     #include <aygshell.h>
  71 #endif
  72
  73 #if wxUSE_OLE
  74     #include <ole2.h>
  75 #endif
  76
  77 #include <string.h>
  78 #include <ctype.h>
  79
  80 // For MB_TASKMODAL
  81 #ifdef __WXWINCE__
  82 #include "wx/msw/wince/missing.h"
  83 #endif
  84
  85 // instead of including <shlwapi.h> which is not part of the core SDK and not
  86 // shipped at all with other compilers, we always define the parts of it we
  87 // need here ourselves
  88 //
  89 // NB: DLLVER_PLATFORM_WINDOWS will be defined if shlwapi.h had been somehow
  90 //     included already
  91 #ifndef DLLVER_PLATFORM_WINDOWS
  92     // hopefully we don't need to change packing as DWORDs should be already
  93     // correctly aligned
  94     struct DLLVERSIONINFO
  95     {
  96         DWORD cbSize;
  97         DWORD dwMajorVersion;                   // Major version
  98         DWORD dwMinorVersion;                   // Minor version
  99         DWORD dwBuildNumber;                    // Build number
 100         DWORD dwPlatformID;                     // DLLVER_PLATFORM_*
 101     };
 102
 103     typedef HRESULT (CALLBACK* DLLGETVERSIONPROC)(DLLVERSIONINFO *);
 104 #endif // defined(DLLVERSIONINFO)
 105
 106
 107 // ---------------------------------------------------------------------------
 108 // global variables
 109 // ---------------------------------------------------------------------------
 110
 111 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 112 extern void wxSetKeyboardHook(bool doIt);
 113 #endif
 114
 115 // NB: all "NoRedraw" classes must have the same names as the "normal" classes
 116 //     with NR suffix - wxWindow::MSWCreate() supposes this
 117 #ifdef __WXWINCE__
 118 WXDLLIMPEXP_CORE       wxChar *wxCanvasClassName;
 119 WXDLLIMPEXP_CORE       wxChar *wxCanvasClassNameNR;
 120 #else
 121 WXDLLIMPEXP_CORE const wxChar *wxCanvasClassName        = wxT("wxWindowClass");
 122 WXDLLIMPEXP_CORE const wxChar *wxCanvasClassNameNR      = wxT("wxWindowClassNR");
 123 #endif
 124 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassName      = wxT("wxMDIFrameClass");
 125 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassNameNoRedraw = wxT("wxMDIFrameClassNR");
 126 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassName = wxT("wxMDIChildFrameClass");
 127 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassNameNoRedraw = wxT("wxMDIChildFrameClassNR");
 128
 129 // ----------------------------------------------------------------------------
 130 // private functions
 131 // ----------------------------------------------------------------------------
 132
 133 LRESULT WXDLLEXPORT APIENTRY wxWndProc(HWND, UINT, WPARAM, LPARAM);
 134
 135 // ===========================================================================
 136 // wxGUIAppTraits implementation
 137 // ===========================================================================
 138
 139 // private class which we use to pass parameters from BeforeChildWaitLoop() to
 140 // AfterChildWaitLoop()
 141 struct ChildWaitLoopData
 142 {
 143     ChildWaitLoopData(wxWindowDisabler *wd_, wxWindow *winActive_)
 144     {
 145         wd = wd_;
 146         winActive = winActive_;
 147     }
 148
 149     wxWindowDisabler *wd;
 150     wxWindow *winActive;
 151 };
 152
 153 void *wxGUIAppTraits::BeforeChildWaitLoop()
 154 {
 155     /*
 156        We use a dirty hack here to disable all application windows (which we
 157        must do because otherwise the calls to wxYield() could lead to some very
 158        unexpected reentrancies in the users code) but to avoid losing
 159        focus/activation entirely when the child process terminates which would
 160        happen if we simply disabled everything using wxWindowDisabler. Indeed,
 161        remember that Windows will never activate a disabled window and when the
 162        last childs window is closed and Windows looks for a window to activate
 163        all our windows are still disabled. There is no way to enable them in
 164        time because we don't know when the childs windows are going to be
 165        closed, so the solution we use here is to keep one special tiny frame
 166        enabled all the time. Then when the child terminates it will get
 167        activated and when we close it below -- after reenabling all the other
 168        windows! -- the previously active window becomes activated again and
 169        everything is ok.
 170      */
 171     wxBeginBusyCursor();
 172
 173     // first disable all existing windows
 174     wxWindowDisabler *wd = new wxWindowDisabler;
 175
 176     // then create an "invisible" frame: it has minimal size, is positioned
 177     // (hopefully) outside the screen and doesn't appear on the taskbar
 178     wxWindow *winActive = new wxFrame
 179                     (
 180                         wxTheApp->GetTopWindow(),
 181                         wxID_ANY,
 182                         wxEmptyString,
 183                         wxPoint(32600, 32600),
 184                         wxSize(1, 1),
 185                         wxDEFAULT_FRAME_STYLE | wxFRAME_NO_TASKBAR
 186                     );
 187     winActive->Show();
 188
 189     return new ChildWaitLoopData(wd, winActive);
 190 }
 191
 192 void wxGUIAppTraits::AlwaysYield()
 193 {
 194     wxYield();
 195 }
 196
 197 void wxGUIAppTraits::AfterChildWaitLoop(void *dataOrig)
 198 {
 199     wxEndBusyCursor();
 200
 201     ChildWaitLoopData * const data = (ChildWaitLoopData *)dataOrig;
 202
 203     delete data->wd;
 204
 205     // finally delete the dummy frame and, as wd has been already destroyed and
 206     // the other windows reenabled, the activation is going to return to the
 207     // window which had had it before
 208     data->winActive->Destroy();
 209
 210     // also delete the temporary data object itself
 211     delete data;
 212 }
 213
 214 bool wxGUIAppTraits::DoMessageFromThreadWait()
 215 {
 216     // we should return false only if the app should exit, i.e. only if
 217     // Dispatch() determines that the main event loop should terminate
 218     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 219     if ( !evtLoop || !evtLoop->Pending() )
 220     {
 221         // no events means no quit event
 222         return true;
 223     }
 224
 225     return evtLoop->Dispatch();
 226 }
 227
 228 wxPortId wxGUIAppTraits::GetToolkitVersion(int *majVer, int *minVer) const
 229 {
 230     OSVERSIONINFO info;
 231     wxZeroMemory(info);
 232
 233     // on Windows, the toolkit version is the same of the OS version
 234     // as Windows integrates the OS kernel with the GUI toolkit.
 235     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
 236     if ( ::GetVersionEx(&info) )
 237     {
 238         if ( majVer )
 239             *majVer = info.dwMajorVersion;
 240         if ( minVer )
 241             *minVer = info.dwMinorVersion;
 242     }
 243
 244 #if defined(__WXHANDHELD__) || defined(__WXWINCE__)
 245     return wxPORT_WINCE;
 246 #else
 247     return wxPORT_MSW;
 248 #endif
 249 }
 250
 251 // ===========================================================================
 252 // wxApp implementation
 253 // ===========================================================================
 254
 255 int wxApp::m_nCmdShow = SW_SHOWNORMAL;
 256
 257 // ---------------------------------------------------------------------------
 258 // wxWin macros
 259 // ---------------------------------------------------------------------------
 260
 261 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
 262
 263 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 264     EVT_IDLE(wxApp::OnIdle)
 265     EVT_END_SESSION(wxApp::OnEndSession)
 266     EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
 267 END_EVENT_TABLE()
 268
 269 // class to ensure that wxAppBase::CleanUp() is called if our Initialize()
 270 // fails
 271 class wxCallBaseCleanup
 272 {
 273 public:
 274     wxCallBaseCleanup(wxApp *app) : m_app(app) { }
 275     ~wxCallBaseCleanup() { if ( m_app ) m_app->wxAppBase::CleanUp(); }
 276
 277     void Dismiss() { m_app = NULL; }
 278
 279 private:
 280     wxApp *m_app;
 281 };
 282
 283 //// Initialize
 284 bool wxApp::Initialize(int& argc, wxChar **argv)
 285 {
 286     if ( !wxAppBase::Initialize(argc, argv) )
 287         return false;
 288
 289     // ensure that base cleanup is done if we return too early
 290     wxCallBaseCleanup callBaseCleanup(this);
 291
 292 #ifdef __WXWINCE__
 293     wxString tmp = GetAppName();
 294     tmp += wxT("ClassName");
 295     wxCanvasClassName = wxStrdup( tmp.c_str() );
 296     tmp += wxT("NR");
 297     wxCanvasClassNameNR = wxStrdup( tmp.c_str() );
 298     HWND hWnd = FindWindow( wxCanvasClassNameNR, NULL );
 299     if (hWnd)
 300     {
 301         SetForegroundWindow( (HWND)(((DWORD)hWnd)|0x01) );
 302         return false;
 303     }
 304 #endif
 305
 306 #if !defined(__WXMICROWIN__)
 307     InitCommonControls();
 308 #endif // !defined(__WXMICROWIN__)
 309
 310 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
 311     SHInitExtraControls();
 312 #endif
 313
 314 #ifndef __WXWINCE__
 315     // Don't show a message box if a function such as SHGetFileInfo
 316     // fails to find a device.
 317     SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
 318 #endif
 319
 320     wxOleInitialize();
 321
 322     RegisterWindowClasses();
 323
 324     wxWinHandleHash = new wxWinHashTable(wxKEY_INTEGER, 100);
 325
 326 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 327     wxSetKeyboardHook(true);
 328 #endif
 329
 330     callBaseCleanup.Dismiss();
 331
 332     return true;
 333 }
 334
 335 // ---------------------------------------------------------------------------
 336 // RegisterWindowClasses
 337 // ---------------------------------------------------------------------------
 338
 339 // TODO we should only register classes really used by the app. For this it
 340 //      would be enough to just delay the class registration until an attempt
 341 //      to create a window of this class is made.
 342 bool wxApp::RegisterWindowClasses()
 343 {
 344     WNDCLASS wndclass;
 345     wxZeroMemory(wndclass);
 346
 347     // for each class we register one with CS_(V|H)REDRAW style and one
 348     // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
 349     static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
 350     static const long styleNoRedraw = CS_DBLCLKS;
 351
 352     // the fields which are common to all classes
 353     wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
 354     wndclass.hInstance     = wxhInstance;
 355     wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
 356
 357     // register the class for all normal windows
 358     wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
 359     wndclass.lpszClassName = wxCanvasClassName;
 360     wndclass.style         = styleNormal;
 361
 362     if ( !RegisterClass(&wndclass) )
 363     {
 364         wxLogLastError(wxT("RegisterClass(frame)"));
 365     }
 366
 367     // "no redraw" frame
 368     wndclass.lpszClassName = wxCanvasClassNameNR;
 369     wndclass.style         = styleNoRedraw;
 370
 371     if ( !RegisterClass(&wndclass) )
 372     {
 373         wxLogLastError(wxT("RegisterClass(no redraw frame)"));
 374     }
 375
 376     // Register the MDI frame window class.
 377     wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
 378     wndclass.lpszClassName = wxMDIFrameClassName;
 379     wndclass.style         = styleNormal;
 380
 381     if ( !RegisterClass(&wndclass) )
 382     {
 383         wxLogLastError(wxT("RegisterClass(MDI parent)"));
 384     }
 385
 386     // "no redraw" MDI frame
 387     wndclass.lpszClassName = wxMDIFrameClassNameNoRedraw;
 388     wndclass.style         = styleNoRedraw;
 389
 390     if ( !RegisterClass(&wndclass) )
 391     {
 392         wxLogLastError(wxT("RegisterClass(no redraw MDI parent frame)"));
 393     }
 394
 395     // Register the MDI child frame window class.
 396     wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
 397     wndclass.lpszClassName = wxMDIChildFrameClassName;
 398     wndclass.style         = styleNormal;
 399
 400     if ( !RegisterClass(&wndclass) )
 401     {
 402         wxLogLastError(wxT("RegisterClass(MDI child)"));
 403     }
 404
 405     // "no redraw" MDI child frame
 406     wndclass.lpszClassName = wxMDIChildFrameClassNameNoRedraw;
 407     wndclass.style         = styleNoRedraw;
 408
 409     if ( !RegisterClass(&wndclass) )
 410     {
 411         wxLogLastError(wxT("RegisterClass(no redraw MDI child)"));
 412     }
 413
 414     return true;
 415 }
 416
 417 // ---------------------------------------------------------------------------
 418 // UnregisterWindowClasses
 419 // ---------------------------------------------------------------------------
 420
 421 bool wxApp::UnregisterWindowClasses()
 422 {
 423     bool retval = true;
 424
 425 #ifndef __WXMICROWIN__
 426     // MDI frame window class.
 427     if ( !::UnregisterClass(wxMDIFrameClassName, wxhInstance) )
 428     {
 429         wxLogLastError(wxT("UnregisterClass(MDI parent)"));
 430
 431         retval = false;
 432     }
 433
 434     // "no redraw" MDI frame
 435     if ( !::UnregisterClass(wxMDIFrameClassNameNoRedraw, wxhInstance) )
 436     {
 437         wxLogLastError(wxT("UnregisterClass(no redraw MDI parent frame)"));
 438
 439         retval = false;
 440     }
 441
 442     // MDI child frame window class.
 443     if ( !::UnregisterClass(wxMDIChildFrameClassName, wxhInstance) )
 444     {
 445         wxLogLastError(wxT("UnregisterClass(MDI child)"));
 446
 447         retval = false;
 448     }
 449
 450     // "no redraw" MDI child frame
 451     if ( !::UnregisterClass(wxMDIChildFrameClassNameNoRedraw, wxhInstance) )
 452     {
 453         wxLogLastError(wxT("UnregisterClass(no redraw MDI child)"));
 454
 455         retval = false;
 456     }
 457
 458     // canvas class name
 459     if ( !::UnregisterClass(wxCanvasClassName, wxhInstance) )
 460     {
 461         wxLogLastError(wxT("UnregisterClass(canvas)"));
 462
 463         retval = false;
 464     }
 465
 466     if ( !::UnregisterClass(wxCanvasClassNameNR, wxhInstance) )
 467     {
 468         wxLogLastError(wxT("UnregisterClass(no redraw canvas)"));
 469
 470         retval = false;
 471     }
 472 #endif // __WXMICROWIN__
 473
 474     return retval;
 475 }
 476
 477 void wxApp::CleanUp()
 478 {
 479     // all objects pending for deletion must be deleted first, otherwise we
 480     // would crash when they use wxWinHandleHash (and UnregisterWindowClasses()
 481     // call wouldn't succeed as long as any windows still exist), so call the
 482     // base class method first and only then do our clean up
 483     wxAppBase::CleanUp();
 484
 485 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 486     wxSetKeyboardHook(false);
 487 #endif
 488
 489     wxOleUninitialize();
 490
 491     // for an EXE the classes are unregistered when it terminates but DLL may
 492     // be loaded several times (load/unload/load) into the same process in
 493     // which case the registration will fail after the first time if we don't
 494     // unregister the classes now
 495     UnregisterWindowClasses();
 496
 497     delete wxWinHandleHash;
 498     wxWinHandleHash = NULL;
 499
 500 #ifdef __WXWINCE__
 501     free( wxCanvasClassName );
 502     free( wxCanvasClassNameNR );
 503 #endif
 504 }
 505
 506 // ----------------------------------------------------------------------------
 507 // wxApp ctor/dtor
 508 // ----------------------------------------------------------------------------
 509
 510 wxApp::wxApp()
 511 {
 512     m_printMode = wxPRINT_WINDOWS;
 513 }
 514
 515 wxApp::~wxApp()
 516 {
 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 void wxApp::DoMessage(WXMSG *pMsg)
 763 {
 764     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 765     if ( evtLoop )
 766         evtLoop->ProcessMessage(pMsg);
 767 }
 768
 769 bool wxApp::DoMessage()
 770 {
 771     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 772     return evtLoop ? evtLoop->Dispatch() : false;
 773 }
 774
 775 bool wxApp::ProcessMessage(WXMSG* pMsg)
 776 {
 777     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 778     return evtLoop && evtLoop->PreProcessMessage(pMsg);
 779 }
 780
 781 #endif // WXWIN_COMPATIBILITY_2_4