src/msw/app.cpp

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