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