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