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 #if wxUSE_DYNLIB_CLASS
 593         // do we have it?
 594         wxDynamicLibrary dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM);
 595
 596         // if so, then we can check for the version
 597         if ( dllComCtl32.IsLoaded() )
 598         {
 599             // now check if the function is available during run-time
 600             wxDYNLIB_FUNCTION( DLLGETVERSIONPROC, DllGetVersion, dllComCtl32 );
 601             if ( pfnDllGetVersion )
 602             {
 603                 DLLVERSIONINFO dvi;
 604                 dvi.cbSize = sizeof(dvi);
 605
 606                 HRESULT hr = (*pfnDllGetVersion)(&dvi);
 607                 if ( FAILED(hr) )
 608                 {
 609                     wxLogApiError(_T("DllGetVersion"), hr);
 610                 }
 611                 else
 612                 {
 613                     // this is incompatible with _WIN32_IE values, but
 614                     // compatible with the other values returned by
 615                     // GetComCtl32Version()
 616                     s_verComCtl32 = 100*dvi.dwMajorVersion +
 617                                         dvi.dwMinorVersion;
 618                 }
 619             }
 620
 621             // if DllGetVersion() is unavailable either during compile or
 622             // run-time, try to guess the version otherwise
 623             if ( !s_verComCtl32 )
 624             {
 625                 // InitCommonControlsEx is unique to 4.70 and later
 626                 void *pfn = dllComCtl32.GetSymbol(_T("InitCommonControlsEx"));
 627                 if ( !pfn )
 628                 {
 629                     // not found, must be 4.00
 630                     s_verComCtl32 = 400;
 631                 }
 632                 else // 4.70+
 633                 {
 634                     // many symbols appeared in comctl32 4.71, could use any of
 635                     // them except may be DllInstall()
 636                     pfn = dllComCtl32.GetSymbol(_T("InitializeFlatSB"));
 637                     if ( !pfn )
 638                     {
 639                         // not found, must be 4.70
 640                         s_verComCtl32 = 470;
 641                     }
 642                     else
 643                     {
 644                         // found, must be 4.71 or later
 645                         s_verComCtl32 = 471;
 646                     }
 647                 }
 648             }
 649         }
 650 #endif
 651     }
 652
 653     return s_verComCtl32;
 654 #endif // Microwin/!Microwin
 655 }
 656
 657 // Yield to incoming messages
 658
 659 bool wxApp::Yield(bool onlyIfNeeded)
 660 {
 661     // MT-FIXME
 662     static bool s_inYield = false;
 663
 664 #if wxUSE_LOG
 665     // disable log flushing from here because a call to wxYield() shouldn't
 666     // normally result in message boxes popping up &c
 667     wxLog::Suspend();
 668 #endif // wxUSE_LOG
 669
 670     if ( s_inYield )
 671     {
 672         if ( !onlyIfNeeded )
 673         {
 674             wxFAIL_MSG( wxT("wxYield called recursively" ) );
 675         }
 676
 677         return false;
 678     }
 679
 680     s_inYield = true;
 681
 682     // we don't want to process WM_QUIT from here - it should be processed in
 683     // the main event loop in order to stop it
 684     MSG msg;
 685     while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) &&
 686             msg.message != WM_QUIT )
 687     {
 688 #if wxUSE_THREADS
 689         wxMutexGuiLeaveOrEnter();
 690 #endif // wxUSE_THREADS
 691
 692         if ( !wxTheApp->Dispatch() )
 693             break;
 694     }
 695
 696     // if there are pending events, we must process them.
 697     ProcessPendingEvents();
 698
 699 #if wxUSE_LOG
 700     // let the logs be flashed again
 701     wxLog::Resume();
 702 #endif // wxUSE_LOG
 703
 704     s_inYield = false;
 705
 706     return true;
 707 }
 708
 709 #if wxUSE_EXCEPTIONS
 710
 711 // ----------------------------------------------------------------------------
 712 // exception handling
 713 // ----------------------------------------------------------------------------
 714
 715 bool wxApp::OnExceptionInMainLoop()
 716 {
 717     // ask the user about what to do: use the Win32 API function here as it
 718     // could be dangerous to use any wxWidgets code in this state
 719     switch (
 720             ::MessageBox
 721               (
 722                 NULL,
 723                 _T("An unhandled exception occurred. Press \"Abort\" to \
 724 terminate the program,\r\n\
 725 \"Retry\" to exit the program normally and \"Ignore\" to try to continue."),
 726                 _T("Unhandled exception"),
 727                 MB_ABORTRETRYIGNORE |
 728                 MB_ICONERROR|
 729                 MB_TASKMODAL
 730               )
 731            )
 732     {
 733         case IDABORT:
 734             throw;
 735
 736         default:
 737             wxFAIL_MSG( _T("unexpected MessageBox() return code") );
 738             // fall through
 739
 740         case IDRETRY:
 741             return false;
 742
 743         case IDIGNORE:
 744             return true;
 745     }
 746 }
 747
 748 #endif // wxUSE_EXCEPTIONS
 749
 750 // ----------------------------------------------------------------------------
 751 // deprecated event loop functions
 752 // ----------------------------------------------------------------------------
 753
 754 #if WXWIN_COMPATIBILITY_2_4
 755
 756 #include "wx/evtloop.h"
 757
 758 void wxApp::DoMessage(WXMSG *pMsg)
 759 {
 760     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 761     if ( evtLoop )
 762         evtLoop->ProcessMessage(pMsg);
 763 }
 764
 765 bool wxApp::DoMessage()
 766 {
 767     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 768     return evtLoop ? evtLoop->Dispatch() : false;
 769 }
 770
 771 bool wxApp::ProcessMessage(WXMSG* pMsg)
 772 {
 773     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 774     return evtLoop && evtLoop->PreProcessMessage(pMsg);
 775 }
 776
 777 #endif // WXWIN_COMPATIBILITY_2_4