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 <aygshell.h>
  73 #endif
  74
  75 #if wxUSE_OLE
  76     #include <ole2.h>
  77 #endif
  78
  79 #include <string.h>
  80 #include <ctype.h>
  81
  82 #include "wx/msw/wrapcctl.h"
  83
  84 // For MB_TASKMODAL
  85 #ifdef __WXWINCE__
  86 #include "wx/msw/wince/missing.h"
  87 #endif
  88
  89 #if (!defined(__MINGW32__) || wxCHECK_W32API_VERSION( 2, 0 )) && \
  90     !defined(__CYGWIN__) && !defined(__DIGITALMARS__) && !defined(__WXWINCE__) && \
  91     (!defined(_MSC_VER) || (_MSC_VER > 1100))
  92     #include <shlwapi.h>
  93 #endif
  94
  95 // ---------------------------------------------------------------------------
  96 // global variables
  97 // ---------------------------------------------------------------------------
  98
  99 extern wxList WXDLLEXPORT wxPendingDelete;
 100
 101 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 102 extern void wxSetKeyboardHook(bool doIt);
 103 #endif
 104
 105 // NB: all "NoRedraw" classes must have the same names as the "normal" classes
 106 //     with NR suffix - wxWindow::MSWCreate() supposes this
 107 #ifdef __WXWINCE__
 108 WXDLLIMPEXP_CORE       wxChar *wxCanvasClassName;
 109 WXDLLIMPEXP_CORE       wxChar *wxCanvasClassNameNR;
 110 #else
 111 WXDLLIMPEXP_CORE const wxChar *wxCanvasClassName        = wxT("wxWindowClass");
 112 WXDLLIMPEXP_CORE const wxChar *wxCanvasClassNameNR      = wxT("wxWindowClassNR");
 113 #endif
 114 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassName      = wxT("wxMDIFrameClass");
 115 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassNameNoRedraw = wxT("wxMDIFrameClassNR");
 116 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassName = wxT("wxMDIChildFrameClass");
 117 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassNameNoRedraw = wxT("wxMDIChildFrameClassNR");
 118
 119 // ----------------------------------------------------------------------------
 120 // private functions
 121 // ----------------------------------------------------------------------------
 122
 123 LRESULT WXDLLEXPORT APIENTRY wxWndProc(HWND, UINT, WPARAM, LPARAM);
 124
 125 // ===========================================================================
 126 // wxGUIAppTraits implementation
 127 // ===========================================================================
 128
 129 // private class which we use to pass parameters from BeforeChildWaitLoop() to
 130 // AfterChildWaitLoop()
 131 struct ChildWaitLoopData
 132 {
 133     ChildWaitLoopData(wxWindowDisabler *wd_, wxWindow *winActive_)
 134     {
 135         wd = wd_;
 136         winActive = winActive_;
 137     }
 138
 139     wxWindowDisabler *wd;
 140     wxWindow *winActive;
 141 };
 142
 143 void *wxGUIAppTraits::BeforeChildWaitLoop()
 144 {
 145     /*
 146        We use a dirty hack here to disable all application windows (which we
 147        must do because otherwise the calls to wxYield() could lead to some very
 148        unexpected reentrancies in the users code) but to avoid losing
 149        focus/activation entirely when the child process terminates which would
 150        happen if we simply disabled everything using wxWindowDisabler. Indeed,
 151        remember that Windows will never activate a disabled window and when the
 152        last childs window is closed and Windows looks for a window to activate
 153        all our windows are still disabled. There is no way to enable them in
 154        time because we don't know when the childs windows are going to be
 155        closed, so the solution we use here is to keep one special tiny frame
 156        enabled all the time. Then when the child terminates it will get
 157        activated and when we close it below -- after reenabling all the other
 158        windows! -- the previously active window becomes activated again and
 159        everything is ok.
 160      */
 161     wxBeginBusyCursor();
 162
 163     // first disable all existing windows
 164     wxWindowDisabler *wd = new wxWindowDisabler;
 165
 166     // then create an "invisible" frame: it has minimal size, is positioned
 167     // (hopefully) outside the screen and doesn't appear on the taskbar
 168     wxWindow *winActive = new wxFrame
 169                     (
 170                         wxTheApp->GetTopWindow(),
 171                         wxID_ANY,
 172                         wxEmptyString,
 173                         wxPoint(32600, 32600),
 174                         wxSize(1, 1),
 175                         wxDEFAULT_FRAME_STYLE | wxFRAME_NO_TASKBAR
 176                     );
 177     winActive->Show();
 178
 179     return new ChildWaitLoopData(wd, winActive);
 180 }
 181
 182 void wxGUIAppTraits::AlwaysYield()
 183 {
 184     wxYield();
 185 }
 186
 187 void wxGUIAppTraits::AfterChildWaitLoop(void *dataOrig)
 188 {
 189     wxEndBusyCursor();
 190
 191     ChildWaitLoopData * const data = (ChildWaitLoopData *)dataOrig;
 192
 193     delete data->wd;
 194
 195     // finally delete the dummy frame and, as wd has been already destroyed and
 196     // the other windows reenabled, the activation is going to return to the
 197     // window which had had it before
 198     data->winActive->Destroy();
 199
 200     // also delete the temporary data object itself
 201     delete data;
 202 }
 203
 204 bool wxGUIAppTraits::DoMessageFromThreadWait()
 205 {
 206     // we should return false only if the app should exit, i.e. only if
 207     // Dispatch() determines that the main event loop should terminate
 208     return !wxTheApp || wxTheApp->Dispatch();
 209 }
 210
 211 wxToolkitInfo& wxGUIAppTraits::GetToolkitInfo()
 212 {
 213     static wxToolkitInfo info;
 214     wxToolkitInfo& baseInfo = wxAppTraits::GetToolkitInfo();
 215     info.versionMajor = baseInfo.versionMajor;
 216     info.versionMinor = baseInfo.versionMinor;
 217     info.os = baseInfo.os;
 218     info.shortName = _T("msw");
 219     info.name = _T("wxMSW");
 220 #ifdef __WXUNIVERSAL__
 221     info.shortName << _T("univ");
 222     info.name << _T("/wxUniversal");
 223 #endif
 224     return info;
 225 }
 226
 227 // ===========================================================================
 228 // wxApp implementation
 229 // ===========================================================================
 230
 231 int wxApp::m_nCmdShow = SW_SHOWNORMAL;
 232
 233 // ---------------------------------------------------------------------------
 234 // wxWin macros
 235 // ---------------------------------------------------------------------------
 236
 237 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
 238
 239 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 240     EVT_IDLE(wxApp::OnIdle)
 241     EVT_END_SESSION(wxApp::OnEndSession)
 242     EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
 243 END_EVENT_TABLE()
 244
 245 // class to ensure that wxAppBase::CleanUp() is called if our Initialize()
 246 // fails
 247 class wxCallBaseCleanup
 248 {
 249 public:
 250     wxCallBaseCleanup(wxApp *app) : m_app(app) { }
 251     ~wxCallBaseCleanup() { if ( m_app ) m_app->wxAppBase::CleanUp(); }
 252
 253     void Dismiss() { m_app = NULL; }
 254
 255 private:
 256     wxApp *m_app;
 257 };
 258
 259 //// Initialize
 260 bool wxApp::Initialize(int& argc, wxChar **argv)
 261 {
 262     if ( !wxAppBase::Initialize(argc, argv) )
 263         return false;
 264
 265     // ensure that base cleanup is done if we return too early
 266     wxCallBaseCleanup callBaseCleanup(this);
 267
 268 #ifdef __WXWINCE__
 269     wxString tmp = GetAppName();
 270     tmp += wxT("ClassName");
 271     wxCanvasClassName = wxStrdup( tmp.c_str() );
 272     tmp += wxT("NR");
 273     wxCanvasClassNameNR = wxStrdup( tmp.c_str() );
 274     HWND hWnd = FindWindow( wxCanvasClassNameNR, NULL );
 275     if (hWnd)
 276     {
 277         SetForegroundWindow( (HWND)(((DWORD)hWnd)|0x01) );
 278         return false;
 279     }
 280 #endif
 281
 282     // the first thing to do is to check if we're trying to run an Unicode
 283     // program under Win9x w/o MSLU emulation layer - if so, abort right now
 284     // as it has no chance to work
 285 #if wxUSE_UNICODE && !wxUSE_UNICODE_MSLU
 286     if ( wxGetOsVersion() != wxWINDOWS_NT && wxGetOsVersion() != wxWINDOWS_CE && wxGetOsVersion() != wxWINDOWS_SMARTPHONE && wxGetOsVersion() != wxWINDOWS_POCKETPC )
 287     {
 288         // note that we can use MessageBoxW() as it's implemented even under
 289         // Win9x - OTOH, we can't use wxGetTranslation() because the file APIs
 290         // used by wxLocale are not
 291         ::MessageBox
 292         (
 293          NULL,
 294          _T("This program uses Unicode and requires Windows NT/2000/XP/CE.\nProgram aborted."),
 295          _T("wxWidgets Fatal Error"),
 296          MB_ICONERROR | MB_OK
 297         );
 298
 299         return false;
 300     }
 301 #endif // wxUSE_UNICODE && !wxUSE_UNICODE_MSLU
 302
 303 #if defined(__WIN95__) && !defined(__WXMICROWIN__)
 304     InitCommonControls();
 305 #endif // __WIN95__
 306
 307 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
 308     SHInitExtraControls();
 309 #endif
 310
 311     wxOleInitialize();
 312
 313     RegisterWindowClasses();
 314
 315 #if wxUSE_PENWINDOWS
 316     wxRegisterPenWin();
 317 #endif
 318
 319     wxWinHandleHash = new wxWinHashTable(wxKEY_INTEGER, 100);
 320
 321 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 322     wxSetKeyboardHook(true);
 323 #endif
 324
 325     callBaseCleanup.Dismiss();
 326
 327     return true;
 328 }
 329
 330 // ---------------------------------------------------------------------------
 331 // RegisterWindowClasses
 332 // ---------------------------------------------------------------------------
 333
 334 // TODO we should only register classes really used by the app. For this it
 335 //      would be enough to just delay the class registration until an attempt
 336 //      to create a window of this class is made.
 337 bool wxApp::RegisterWindowClasses()
 338 {
 339     WNDCLASS wndclass;
 340     wxZeroMemory(wndclass);
 341
 342     // for each class we register one with CS_(V|H)REDRAW style and one
 343     // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
 344     static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
 345     static const long styleNoRedraw = CS_DBLCLKS;
 346
 347     // the fields which are common to all classes
 348     wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
 349     wndclass.hInstance     = wxhInstance;
 350     wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
 351
 352     // register the class for all normal windows
 353     wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
 354     wndclass.lpszClassName = wxCanvasClassName;
 355     wndclass.style         = styleNormal;
 356
 357     if ( !RegisterClass(&wndclass) )
 358     {
 359         wxLogLastError(wxT("RegisterClass(frame)"));
 360     }
 361
 362     // "no redraw" frame
 363     wndclass.lpszClassName = wxCanvasClassNameNR;
 364     wndclass.style         = styleNoRedraw;
 365
 366     if ( !RegisterClass(&wndclass) )
 367     {
 368         wxLogLastError(wxT("RegisterClass(no redraw frame)"));
 369     }
 370
 371     // Register the MDI frame window class.
 372     wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
 373     wndclass.lpszClassName = wxMDIFrameClassName;
 374     wndclass.style         = styleNormal;
 375
 376     if ( !RegisterClass(&wndclass) )
 377     {
 378         wxLogLastError(wxT("RegisterClass(MDI parent)"));
 379     }
 380
 381     // "no redraw" MDI frame
 382     wndclass.lpszClassName = wxMDIFrameClassNameNoRedraw;
 383     wndclass.style         = styleNoRedraw;
 384
 385     if ( !RegisterClass(&wndclass) )
 386     {
 387         wxLogLastError(wxT("RegisterClass(no redraw MDI parent frame)"));
 388     }
 389
 390     // Register the MDI child frame window class.
 391     wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
 392     wndclass.lpszClassName = wxMDIChildFrameClassName;
 393     wndclass.style         = styleNormal;
 394
 395     if ( !RegisterClass(&wndclass) )
 396     {
 397         wxLogLastError(wxT("RegisterClass(MDI child)"));
 398     }
 399
 400     // "no redraw" MDI child frame
 401     wndclass.lpszClassName = wxMDIChildFrameClassNameNoRedraw;
 402     wndclass.style         = styleNoRedraw;
 403
 404     if ( !RegisterClass(&wndclass) )
 405     {
 406         wxLogLastError(wxT("RegisterClass(no redraw MDI child)"));
 407     }
 408
 409     return true;
 410 }
 411
 412 // ---------------------------------------------------------------------------
 413 // UnregisterWindowClasses
 414 // ---------------------------------------------------------------------------
 415
 416 bool wxApp::UnregisterWindowClasses()
 417 {
 418     bool retval = true;
 419
 420 #ifndef __WXMICROWIN__
 421     // MDI frame window class.
 422     if ( !::UnregisterClass(wxMDIFrameClassName, wxhInstance) )
 423     {
 424         wxLogLastError(wxT("UnregisterClass(MDI parent)"));
 425
 426         retval = false;
 427     }
 428
 429     // "no redraw" MDI frame
 430     if ( !::UnregisterClass(wxMDIFrameClassNameNoRedraw, wxhInstance) )
 431     {
 432         wxLogLastError(wxT("UnregisterClass(no redraw MDI parent frame)"));
 433
 434         retval = false;
 435     }
 436
 437     // MDI child frame window class.
 438     if ( !::UnregisterClass(wxMDIChildFrameClassName, wxhInstance) )
 439     {
 440         wxLogLastError(wxT("UnregisterClass(MDI child)"));
 441
 442         retval = false;
 443     }
 444
 445     // "no redraw" MDI child frame
 446     if ( !::UnregisterClass(wxMDIChildFrameClassNameNoRedraw, wxhInstance) )
 447     {
 448         wxLogLastError(wxT("UnregisterClass(no redraw MDI child)"));
 449
 450         retval = false;
 451     }
 452
 453     // canvas class name
 454     if ( !::UnregisterClass(wxCanvasClassName, wxhInstance) )
 455     {
 456         wxLogLastError(wxT("UnregisterClass(canvas)"));
 457
 458         retval = false;
 459     }
 460
 461     if ( !::UnregisterClass(wxCanvasClassNameNR, wxhInstance) )
 462     {
 463         wxLogLastError(wxT("UnregisterClass(no redraw canvas)"));
 464
 465         retval = false;
 466     }
 467 #endif // __WXMICROWIN__
 468
 469     return retval;
 470 }
 471
 472 void wxApp::CleanUp()
 473 {
 474     // all objects pending for deletion must be deleted first, otherwise we
 475     // would crash when they use wxWinHandleHash (and UnregisterWindowClasses()
 476     // call wouldn't succeed as long as any windows still exist), so call the
 477     // base class method first and only then do our clean up
 478     wxAppBase::CleanUp();
 479
 480 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 481     wxSetKeyboardHook(false);
 482 #endif
 483
 484 #if wxUSE_PENWINDOWS
 485     wxCleanUpPenWin();
 486 #endif
 487
 488     wxOleUninitialize();
 489
 490     // for an EXE the classes are unregistered when it terminates but DLL may
 491     // be loaded several times (load/unload/load) into the same process in
 492     // which case the registration will fail after the first time if we don't
 493     // unregister the classes now
 494     UnregisterWindowClasses();
 495
 496     delete wxWinHandleHash;
 497     wxWinHandleHash = NULL;
 498
 499 #ifdef __WXWINCE__
 500     free( wxCanvasClassName );
 501     free( wxCanvasClassNameNR );
 502 #endif
 503 }
 504
 505 // ----------------------------------------------------------------------------
 506 // wxApp ctor/dtor
 507 // ----------------------------------------------------------------------------
 508
 509 wxApp::wxApp()
 510 {
 511     m_printMode = wxPRINT_WINDOWS;
 512 }
 513
 514 wxApp::~wxApp()
 515 {
 516     // our cmd line arguments are allocated inside wxEntry(HINSTANCE), they
 517     // don't come from main(), so we have to free them
 518
 519     while ( argc )
 520     {
 521         // m_argv elements were allocated by wxStrdup()
 522         free(argv[--argc]);
 523     }
 524
 525     // but m_argv itself -- using new[]
 526     delete [] argv;
 527 }
 528
 529 // ----------------------------------------------------------------------------
 530 // wxApp idle handling
 531 // ----------------------------------------------------------------------------
 532
 533 void wxApp::OnIdle(wxIdleEvent& event)
 534 {
 535     wxAppBase::OnIdle(event);
 536
 537 #if wxUSE_DC_CACHEING
 538     // automated DC cache management: clear the cached DCs and bitmap
 539     // if it's likely that the app has finished with them, that is, we
 540     // get an idle event and we're not dragging anything.
 541     if (!::GetKeyState(MK_LBUTTON) && !::GetKeyState(MK_MBUTTON) && !::GetKeyState(MK_RBUTTON))
 542         wxDC::ClearCache();
 543 #endif // wxUSE_DC_CACHEING
 544 }
 545
 546 void wxApp::WakeUpIdle()
 547 {
 548     // Send the top window a dummy message so idle handler processing will
 549     // start up again.  Doing it this way ensures that the idle handler
 550     // wakes up in the right thread (see also wxWakeUpMainThread() which does
 551     // the same for the main app thread only)
 552     wxWindow *topWindow = wxTheApp->GetTopWindow();
 553     if ( topWindow )
 554     {
 555         if ( !::PostMessage(GetHwndOf(topWindow), WM_NULL, 0, 0) )
 556         {
 557             // should never happen
 558             wxLogLastError(wxT("PostMessage(WM_NULL)"));
 559         }
 560     }
 561 }
 562
 563 // ----------------------------------------------------------------------------
 564 // other wxApp event hanlders
 565 // ----------------------------------------------------------------------------
 566
 567 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
 568 {
 569     if (GetTopWindow())
 570         GetTopWindow()->Close(true);
 571 }
 572
 573 // Default behaviour: close the application with prompts. The
 574 // user can veto the close, and therefore the end session.
 575 void wxApp::OnQueryEndSession(wxCloseEvent& event)
 576 {
 577     if (GetTopWindow())
 578     {
 579         if (!GetTopWindow()->Close(!event.CanVeto()))
 580             event.Veto(true);
 581     }
 582 }
 583
 584 // ----------------------------------------------------------------------------
 585 // miscellaneous
 586 // ----------------------------------------------------------------------------
 587
 588 /* static */
 589 int wxApp::GetComCtl32Version()
 590 {
 591 #if defined(__WXMICROWIN__) || defined(__WXWINCE__)
 592     return 0;
 593 #else
 594     // cache the result
 595     //
 596     // NB: this is MT-ok as in the worst case we'd compute s_verComCtl32 twice,
 597     //     but as its value should be the same both times it doesn't matter
 598     static int s_verComCtl32 = -1;
 599
 600     if ( s_verComCtl32 == -1 )
 601     {
 602         // initally assume no comctl32.dll at all
 603         s_verComCtl32 = 0;
 604
 605         // we're prepared to handle the errors
 606         wxLogNull noLog;
 607
 608         // do we have it?
 609         wxDynamicLibrary dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM);
 610
 611         // if so, then we can check for the version
 612         if ( dllComCtl32.IsLoaded() )
 613         {
 614 #ifdef DLLVER_PLATFORM_WINDOWS
 615             // try to use DllGetVersion() if available in _headers_
 616             wxDYNLIB_FUNCTION( DLLGETVERSIONPROC, DllGetVersion, dllComCtl32 );
 617             if ( pfnDllGetVersion )
 618             {
 619                 DLLVERSIONINFO dvi;
 620                 dvi.cbSize = sizeof(dvi);
 621
 622                 HRESULT hr = (*pfnDllGetVersion)(&dvi);
 623                 if ( FAILED(hr) )
 624                 {
 625                     wxLogApiError(_T("DllGetVersion"), hr);
 626                 }
 627                 else
 628                 {
 629                     // this is incompatible with _WIN32_IE values, but
 630                     // compatible with the other values returned by
 631                     // GetComCtl32Version()
 632                     s_verComCtl32 = 100*dvi.dwMajorVersion +
 633                                         dvi.dwMinorVersion;
 634                 }
 635             }
 636 #endif
 637
 638             // if DllGetVersion() is unavailable either during compile or
 639             // run-time, try to guess the version otherwise
 640             if ( !s_verComCtl32 )
 641             {
 642                 // InitCommonControlsEx is unique to 4.70 and later
 643                 void *pfn = dllComCtl32.GetSymbol(_T("InitCommonControlsEx"));
 644                 if ( !pfn )
 645                 {
 646                     // not found, must be 4.00
 647                     s_verComCtl32 = 400;
 648                 }
 649                 else // 4.70+
 650                 {
 651                     // many symbols appeared in comctl32 4.71, could use any of
 652                     // them except may be DllInstall()
 653                     pfn = dllComCtl32.GetSymbol(_T("InitializeFlatSB"));
 654                     if ( !pfn )
 655                     {
 656                         // not found, must be 4.70
 657                         s_verComCtl32 = 470;
 658                     }
 659                     else
 660                     {
 661                         // found, must be 4.71 or later
 662                         s_verComCtl32 = 471;
 663                     }
 664                 }
 665             }
 666         }
 667     }
 668
 669     return s_verComCtl32;
 670 #endif // Microwin/!Microwin
 671 }
 672
 673 // Yield to incoming messages
 674
 675 bool wxApp::Yield(bool onlyIfNeeded)
 676 {
 677     // MT-FIXME
 678     static bool s_inYield = false;
 679
 680 #if wxUSE_LOG
 681     // disable log flushing from here because a call to wxYield() shouldn't
 682     // normally result in message boxes popping up &c
 683     wxLog::Suspend();
 684 #endif // wxUSE_LOG
 685
 686     if ( s_inYield )
 687     {
 688         if ( !onlyIfNeeded )
 689         {
 690             wxFAIL_MSG( wxT("wxYield called recursively" ) );
 691         }
 692
 693         return false;
 694     }
 695
 696     s_inYield = true;
 697
 698     // we don't want to process WM_QUIT from here - it should be processed in
 699     // the main event loop in order to stop it
 700     MSG msg;
 701     while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) &&
 702             msg.message != WM_QUIT )
 703     {
 704 #if wxUSE_THREADS
 705         wxMutexGuiLeaveOrEnter();
 706 #endif // wxUSE_THREADS
 707
 708         if ( !wxTheApp->Dispatch() )
 709             break;
 710     }
 711
 712     // if there are pending events, we must process them.
 713     ProcessPendingEvents();
 714
 715 #if wxUSE_LOG
 716     // let the logs be flashed again
 717     wxLog::Resume();
 718 #endif // wxUSE_LOG
 719
 720     s_inYield = false;
 721
 722     return true;
 723 }
 724
 725 #if wxUSE_EXCEPTIONS
 726
 727 // ----------------------------------------------------------------------------
 728 // exception handling
 729 // ----------------------------------------------------------------------------
 730
 731 bool wxApp::OnExceptionInMainLoop()
 732 {
 733     // ask the user about what to do: use the Win32 API function here as it
 734     // could be dangerous to use any wxWidgets code in this state
 735     switch (
 736             ::MessageBox
 737               (
 738                 NULL,
 739                 _T("An unhandled exception occurred. Press \"Abort\" to \
 740 terminate the program,\r\n\
 741 \"Retry\" to exit the program normally and \"Ignore\" to try to continue."),
 742                 _T("Unhandled exception"),
 743                 MB_ABORTRETRYIGNORE |
 744                 MB_ICONERROR|
 745                 MB_TASKMODAL
 746               )
 747            )
 748     {
 749         case IDABORT:
 750             throw;
 751
 752         default:
 753             wxFAIL_MSG( _T("unexpected MessageBox() return code") );
 754             // fall through
 755
 756         case IDRETRY:
 757             return false;
 758
 759         case IDIGNORE:
 760             return true;
 761     }
 762 }
 763
 764 #endif // wxUSE_EXCEPTIONS
 765
 766 // ----------------------------------------------------------------------------
 767 // deprecated event loop functions
 768 // ----------------------------------------------------------------------------
 769
 770 #if WXWIN_COMPATIBILITY_2_4
 771
 772 #include "wx/evtloop.h"
 773
 774 void wxApp::DoMessage(WXMSG *pMsg)
 775 {
 776     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 777     if ( evtLoop )
 778         evtLoop->ProcessMessage(pMsg);
 779 }
 780
 781 bool wxApp::DoMessage()
 782 {
 783     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 784     return evtLoop ? evtLoop->Dispatch() : false;
 785 }
 786
 787 bool wxApp::ProcessMessage(WXMSG* pMsg)
 788 {
 789     wxEventLoop *evtLoop = wxEventLoop::GetActive();
 790     return evtLoop && evtLoop->PreProcessMessage(pMsg);
 791 }
 792
 793 #endif // WXWIN_COMPATIBILITY_2_4
 794