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/msw/wrapcctl.h"
  29     #include "wx/dynarray.h"
  30     #include "wx/frame.h"
  31     #include "wx/app.h"
  32     #include "wx/utils.h"
  33     #include "wx/gdicmn.h"
  34     #include "wx/pen.h"
  35     #include "wx/brush.h"
  36     #include "wx/cursor.h"
  37     #include "wx/icon.h"
  38     #include "wx/palette.h"
  39     #include "wx/dc.h"
  40     #include "wx/dialog.h"
  41     #include "wx/msgdlg.h"
  42     #include "wx/intl.h"
  43     #include "wx/crt.h"
  44     #include "wx/log.h"
  45     #include "wx/module.h"
  46 #endif
  47
  48 #include "wx/apptrait.h"
  49 #include "wx/filename.h"
  50 #include "wx/dynlib.h"
  51 #include "wx/evtloop.h"
  52 #include "wx/thread.h"
  53
  54 #include "wx/msw/private.h"
  55 #include "wx/msw/dc.h"
  56 #include "wx/msw/ole/oleutils.h"
  57 #include "wx/msw/private/timer.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__)
  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/missing.h"
  84
  85 // instead of including <shlwapi.h> which is not part of the core SDK and not
  86 // shipped at all with other compilers, we always define the parts of it we
  87 // need here ourselves
  88 //
  89 // NB: DLLVER_PLATFORM_WINDOWS will be defined if shlwapi.h had been somehow
  90 //     included already
  91 #ifndef DLLVER_PLATFORM_WINDOWS
  92     // hopefully we don't need to change packing as DWORDs should be already
  93     // correctly aligned
  94     struct DLLVERSIONINFO
  95     {
  96         DWORD cbSize;
  97         DWORD dwMajorVersion;                   // Major version
  98         DWORD dwMinorVersion;                   // Minor version
  99         DWORD dwBuildNumber;                    // Build number
 100         DWORD dwPlatformID;                     // DLLVER_PLATFORM_*
 101     };
 102
 103     typedef HRESULT (CALLBACK* DLLGETVERSIONPROC)(DLLVERSIONINFO *);
 104 #endif // defined(DLLVERSIONINFO)
 105
 106
 107 // ---------------------------------------------------------------------------
 108 // global variables
 109 // ---------------------------------------------------------------------------
 110
 111 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 112 extern void wxSetKeyboardHook(bool doIt);
 113 #endif
 114
 115 // NB: all "NoRedraw" classes must have the same names as the "normal" classes
 116 //     with NR suffix - wxWindow::MSWCreate() supposes this
 117 #ifdef __WXWINCE__
 118 WXDLLIMPEXP_CORE       wxChar *wxCanvasClassName;
 119 WXDLLIMPEXP_CORE       wxChar *wxCanvasClassNameNR;
 120 #else
 121 WXDLLIMPEXP_CORE const wxChar *wxCanvasClassName        = wxT("wxWindowClass");
 122 WXDLLIMPEXP_CORE const wxChar *wxCanvasClassNameNR      = wxT("wxWindowClassNR");
 123 #endif
 124 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassName      = wxT("wxMDIFrameClass");
 125 WXDLLIMPEXP_CORE const wxChar *wxMDIFrameClassNameNoRedraw = wxT("wxMDIFrameClassNR");
 126 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassName = wxT("wxMDIChildFrameClass");
 127 WXDLLIMPEXP_CORE const wxChar *wxMDIChildFrameClassNameNoRedraw = wxT("wxMDIChildFrameClassNR");
 128
 129 // ----------------------------------------------------------------------------
 130 // private functions
 131 // ----------------------------------------------------------------------------
 132
 133 LRESULT WXDLLEXPORT APIENTRY wxWndProc(HWND, UINT, WPARAM, LPARAM);
 134
 135 // ===========================================================================
 136 // wxGUIAppTraits implementation
 137 // ===========================================================================
 138
 139 // private class which we use to pass parameters from BeforeChildWaitLoop() to
 140 // AfterChildWaitLoop()
 141 struct ChildWaitLoopData
 142 {
 143     ChildWaitLoopData(wxWindowDisabler *wd_, wxWindow *winActive_)
 144     {
 145         wd = wd_;
 146         winActive = winActive_;
 147     }
 148
 149     wxWindowDisabler *wd;
 150     wxWindow *winActive;
 151 };
 152
 153 void *wxGUIAppTraits::BeforeChildWaitLoop()
 154 {
 155     /*
 156        We use a dirty hack here to disable all application windows (which we
 157        must do because otherwise the calls to wxYield() could lead to some very
 158        unexpected reentrancies in the users code) but to avoid losing
 159        focus/activation entirely when the child process terminates which would
 160        happen if we simply disabled everything using wxWindowDisabler. Indeed,
 161        remember that Windows will never activate a disabled window and when the
 162        last childs window is closed and Windows looks for a window to activate
 163        all our windows are still disabled. There is no way to enable them in
 164        time because we don't know when the childs windows are going to be
 165        closed, so the solution we use here is to keep one special tiny frame
 166        enabled all the time. Then when the child terminates it will get
 167        activated and when we close it below -- after reenabling all the other
 168        windows! -- the previously active window becomes activated again and
 169        everything is ok.
 170      */
 171     wxBeginBusyCursor();
 172
 173     // first disable all existing windows
 174     wxWindowDisabler *wd = new wxWindowDisabler;
 175
 176     // then create an "invisible" frame: it has minimal size, is positioned
 177     // (hopefully) outside the screen and doesn't appear on the taskbar
 178     wxWindow *winActive = new wxFrame
 179                     (
 180                         wxTheApp->GetTopWindow(),
 181                         wxID_ANY,
 182                         wxEmptyString,
 183                         wxPoint(32600, 32600),
 184                         wxSize(1, 1),
 185                         wxDEFAULT_FRAME_STYLE | wxFRAME_NO_TASKBAR
 186                     );
 187     winActive->Show();
 188
 189     return new ChildWaitLoopData(wd, winActive);
 190 }
 191
 192 void wxGUIAppTraits::AlwaysYield()
 193 {
 194     wxYield();
 195 }
 196
 197 void wxGUIAppTraits::AfterChildWaitLoop(void *dataOrig)
 198 {
 199     wxEndBusyCursor();
 200
 201     ChildWaitLoopData * const data = (ChildWaitLoopData *)dataOrig;
 202
 203     delete data->wd;
 204
 205     // finally delete the dummy frame and, as wd has been already destroyed and
 206     // the other windows reenabled, the activation is going to return to the
 207     // window which had had it before
 208     data->winActive->Destroy();
 209
 210     // also delete the temporary data object itself
 211     delete data;
 212 }
 213
 214 bool wxGUIAppTraits::DoMessageFromThreadWait()
 215 {
 216     // we should return false only if the app should exit, i.e. only if
 217     // Dispatch() determines that the main event loop should terminate
 218     wxEventLoopBase * const evtLoop = wxEventLoop::GetActive();
 219     if ( !evtLoop || !evtLoop->Pending() )
 220     {
 221         // no events means no quit event
 222         return true;
 223     }
 224
 225     return evtLoop->Dispatch();
 226 }
 227
 228 DWORD wxGUIAppTraits::WaitForThread(WXHANDLE hThread)
 229 {
 230     // if we don't have a running event loop, we shouldn't wait for the
 231     // messages as we never remove them from the message queue and so we enter
 232     // an infinite loop as MsgWaitForMultipleObjects() keeps returning
 233     // WAIT_OBJECT_0 + 1
 234     if ( !wxEventLoop::GetActive() )
 235         return DoSimpleWaitForThread(hThread);
 236
 237     return ::MsgWaitForMultipleObjects
 238              (
 239                1,                   // number of objects to wait for
 240                (HANDLE *)&hThread,  // the objects
 241                false,               // wait for any objects, not all
 242                INFINITE,            // no timeout
 243                QS_ALLINPUT |        // return as soon as there are any events
 244                QS_ALLPOSTMESSAGE
 245              );
 246 }
 247
 248 wxPortId wxGUIAppTraits::GetToolkitVersion(int *majVer, int *minVer) const
 249 {
 250     OSVERSIONINFO info;
 251     wxZeroMemory(info);
 252
 253     // on Windows, the toolkit version is the same of the OS version
 254     // as Windows integrates the OS kernel with the GUI toolkit.
 255     info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
 256     if ( ::GetVersionEx(&info) )
 257     {
 258         if ( majVer )
 259             *majVer = info.dwMajorVersion;
 260         if ( minVer )
 261             *minVer = info.dwMinorVersion;
 262     }
 263
 264 #if defined(__WXHANDHELD__) || defined(__WXWINCE__)
 265     return wxPORT_WINCE;
 266 #else
 267     return wxPORT_MSW;
 268 #endif
 269 }
 270
 271 #if wxUSE_TIMER
 272
 273 wxTimerImpl *wxGUIAppTraits::CreateTimerImpl(wxTimer *timer)
 274 {
 275     return new wxMSWTimerImpl(timer);
 276 }
 277
 278 #endif // wxUSE_TIMER
 279
 280 wxEventLoopBase* wxGUIAppTraits::CreateEventLoop()
 281 {
 282     return new wxEventLoop;
 283 }
 284
 285 // ===========================================================================
 286 // wxApp implementation
 287 // ===========================================================================
 288
 289 int wxApp::m_nCmdShow = SW_SHOWNORMAL;
 290
 291 // ---------------------------------------------------------------------------
 292 // wxWin macros
 293 // ---------------------------------------------------------------------------
 294
 295 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
 296
 297 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 298     EVT_IDLE(wxApp::OnIdle)
 299     EVT_END_SESSION(wxApp::OnEndSession)
 300     EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
 301 END_EVENT_TABLE()
 302
 303 // class to ensure that wxAppBase::CleanUp() is called if our Initialize()
 304 // fails
 305 class wxCallBaseCleanup
 306 {
 307 public:
 308     wxCallBaseCleanup(wxApp *app) : m_app(app) { }
 309     ~wxCallBaseCleanup() { if ( m_app ) m_app->wxAppBase::CleanUp(); }
 310
 311     void Dismiss() { m_app = NULL; }
 312
 313 private:
 314     wxApp *m_app;
 315 };
 316
 317 //// Initialize
 318 bool wxApp::Initialize(int& argc, wxChar **argv)
 319 {
 320     if ( !wxAppBase::Initialize(argc, argv) )
 321         return false;
 322
 323     // ensure that base cleanup is done if we return too early
 324     wxCallBaseCleanup callBaseCleanup(this);
 325
 326 #ifdef __WXWINCE__
 327     wxString tmp = GetAppName();
 328     tmp += wxT("ClassName");
 329     wxCanvasClassName = wxStrdup( tmp.wc_str() );
 330     tmp += wxT("NR");
 331     wxCanvasClassNameNR = wxStrdup( tmp.wc_str() );
 332     HWND hWnd = FindWindow( wxCanvasClassNameNR, NULL );
 333     if (hWnd)
 334     {
 335         SetForegroundWindow( (HWND)(((DWORD)hWnd)|0x01) );
 336         return false;
 337     }
 338 #endif
 339
 340 #if !defined(__WXMICROWIN__)
 341     InitCommonControls();
 342 #endif // !defined(__WXMICROWIN__)
 343
 344 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
 345     SHInitExtraControls();
 346 #endif
 347
 348 #ifndef __WXWINCE__
 349     // Don't show a message box if a function such as SHGetFileInfo
 350     // fails to find a device.
 351     SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
 352 #endif
 353
 354     wxOleInitialize();
 355
 356     RegisterWindowClasses();
 357
 358 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 359     wxSetKeyboardHook(true);
 360 #endif
 361
 362     callBaseCleanup.Dismiss();
 363
 364     return true;
 365 }
 366
 367 // ---------------------------------------------------------------------------
 368 // RegisterWindowClasses
 369 // ---------------------------------------------------------------------------
 370
 371 // TODO we should only register classes really used by the app. For this it
 372 //      would be enough to just delay the class registration until an attempt
 373 //      to create a window of this class is made.
 374 bool wxApp::RegisterWindowClasses()
 375 {
 376     WNDCLASS wndclass;
 377     wxZeroMemory(wndclass);
 378
 379     // for each class we register one with CS_(V|H)REDRAW style and one
 380     // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
 381     static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
 382     static const long styleNoRedraw = CS_DBLCLKS;
 383
 384     // the fields which are common to all classes
 385     wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
 386     wndclass.hInstance     = wxhInstance;
 387     wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
 388
 389     // register the class for all normal windows
 390     wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
 391     wndclass.lpszClassName = wxCanvasClassName;
 392     wndclass.style         = styleNormal;
 393
 394     if ( !RegisterClass(&wndclass) )
 395     {
 396         wxLogLastError(wxT("RegisterClass(frame)"));
 397     }
 398
 399     // "no redraw" frame
 400     wndclass.lpszClassName = wxCanvasClassNameNR;
 401     wndclass.style         = styleNoRedraw;
 402
 403     if ( !RegisterClass(&wndclass) )
 404     {
 405         wxLogLastError(wxT("RegisterClass(no redraw frame)"));
 406     }
 407
 408     // Register the MDI frame window class.
 409     wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
 410     wndclass.lpszClassName = wxMDIFrameClassName;
 411     wndclass.style         = styleNormal;
 412
 413     if ( !RegisterClass(&wndclass) )
 414     {
 415         wxLogLastError(wxT("RegisterClass(MDI parent)"));
 416     }
 417
 418     // "no redraw" MDI frame
 419     wndclass.lpszClassName = wxMDIFrameClassNameNoRedraw;
 420     wndclass.style         = styleNoRedraw;
 421
 422     if ( !RegisterClass(&wndclass) )
 423     {
 424         wxLogLastError(wxT("RegisterClass(no redraw MDI parent frame)"));
 425     }
 426
 427     // Register the MDI child frame window class.
 428     wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
 429     wndclass.lpszClassName = wxMDIChildFrameClassName;
 430     wndclass.style         = styleNormal;
 431
 432     if ( !RegisterClass(&wndclass) )
 433     {
 434         wxLogLastError(wxT("RegisterClass(MDI child)"));
 435     }
 436
 437     // "no redraw" MDI child frame
 438     wndclass.lpszClassName = wxMDIChildFrameClassNameNoRedraw;
 439     wndclass.style         = styleNoRedraw;
 440
 441     if ( !RegisterClass(&wndclass) )
 442     {
 443         wxLogLastError(wxT("RegisterClass(no redraw MDI child)"));
 444     }
 445
 446     return true;
 447 }
 448
 449 // ---------------------------------------------------------------------------
 450 // UnregisterWindowClasses
 451 // ---------------------------------------------------------------------------
 452
 453 bool wxApp::UnregisterWindowClasses()
 454 {
 455     bool retval = true;
 456
 457 #ifndef __WXMICROWIN__
 458     // MDI frame window class.
 459     if ( !::UnregisterClass(wxMDIFrameClassName, wxhInstance) )
 460     {
 461         wxLogLastError(wxT("UnregisterClass(MDI parent)"));
 462
 463         retval = false;
 464     }
 465
 466     // "no redraw" MDI frame
 467     if ( !::UnregisterClass(wxMDIFrameClassNameNoRedraw, wxhInstance) )
 468     {
 469         wxLogLastError(wxT("UnregisterClass(no redraw MDI parent frame)"));
 470
 471         retval = false;
 472     }
 473
 474     // MDI child frame window class.
 475     if ( !::UnregisterClass(wxMDIChildFrameClassName, wxhInstance) )
 476     {
 477         wxLogLastError(wxT("UnregisterClass(MDI child)"));
 478
 479         retval = false;
 480     }
 481
 482     // "no redraw" MDI child frame
 483     if ( !::UnregisterClass(wxMDIChildFrameClassNameNoRedraw, wxhInstance) )
 484     {
 485         wxLogLastError(wxT("UnregisterClass(no redraw MDI child)"));
 486
 487         retval = false;
 488     }
 489
 490     // canvas class name
 491     if ( !::UnregisterClass(wxCanvasClassName, wxhInstance) )
 492     {
 493         wxLogLastError(wxT("UnregisterClass(canvas)"));
 494
 495         retval = false;
 496     }
 497
 498     if ( !::UnregisterClass(wxCanvasClassNameNR, wxhInstance) )
 499     {
 500         wxLogLastError(wxT("UnregisterClass(no redraw canvas)"));
 501
 502         retval = false;
 503     }
 504 #endif // __WXMICROWIN__
 505
 506     return retval;
 507 }
 508
 509 void wxApp::CleanUp()
 510 {
 511     // all objects pending for deletion must be deleted first, otherwise
 512     // UnregisterWindowClasses() call wouldn't succeed (because windows
 513     // using the classes being unregistered still exist), so call the base
 514     // class method first and only then do our clean up
 515     wxAppBase::CleanUp();
 516
 517 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 518     wxSetKeyboardHook(false);
 519 #endif
 520
 521     wxOleUninitialize();
 522
 523     // for an EXE the classes are unregistered when it terminates but DLL may
 524     // be loaded several times (load/unload/load) into the same process in
 525     // which case the registration will fail after the first time if we don't
 526     // unregister the classes now
 527     UnregisterWindowClasses();
 528
 529 #ifdef __WXWINCE__
 530     free( wxCanvasClassName );
 531     free( wxCanvasClassNameNR );
 532 #endif
 533 }
 534
 535 // ----------------------------------------------------------------------------
 536 // wxApp ctor/dtor
 537 // ----------------------------------------------------------------------------
 538
 539 wxApp::wxApp()
 540 {
 541     m_printMode = wxPRINT_WINDOWS;
 542 }
 543
 544 wxApp::~wxApp()
 545 {
 546 }
 547
 548 // ----------------------------------------------------------------------------
 549 // wxApp idle handling
 550 // ----------------------------------------------------------------------------
 551
 552 void wxApp::OnIdle(wxIdleEvent& WXUNUSED(event))
 553 {
 554 #if wxUSE_DC_CACHEING
 555     // automated DC cache management: clear the cached DCs and bitmap
 556     // if it's likely that the app has finished with them, that is, we
 557     // get an idle event and we're not dragging anything.
 558     if (!::GetKeyState(MK_LBUTTON) && !::GetKeyState(MK_MBUTTON) && !::GetKeyState(MK_RBUTTON))
 559         wxMSWDCImpl::ClearCache();
 560 #endif // wxUSE_DC_CACHEING
 561 }
 562
 563 void wxApp::WakeUpIdle()
 564 {
 565     // Send the top window a dummy message so idle handler processing will
 566     // start up again.  Doing it this way ensures that the idle handler
 567     // wakes up in the right thread (see also wxWakeUpMainThread() which does
 568     // the same for the main app thread only)
 569     wxWindow * const topWindow = wxTheApp->GetTopWindow();
 570     if ( topWindow )
 571     {
 572         HWND hwndTop = GetHwndOf(topWindow);
 573
 574         // Do not post WM_NULL if there's already a pending WM_NULL to avoid
 575         // overflowing the message queue.
 576         //
 577         // Notice that due to a limitation of PeekMessage() API (which handles
 578         // 0,0 range specially), we have to check the range from 0-1 instead.
 579         // This still makes it possible to overflow the queue with WM_NULLs by
 580         // interspersing the calles to WakeUpIdle() with windows creation but
 581         // it should be rather hard to do it accidentally.
 582         MSG msg;
 583         if ( !::PeekMessage(&msg, hwndTop, 0, 1, PM_NOREMOVE) ||
 584               ::PeekMessage(&msg, hwndTop, 1, 1, PM_NOREMOVE) )
 585         {
 586             if ( !::PostMessage(hwndTop, WM_NULL, 0, 0) )
 587             {
 588                 // should never happen
 589                 wxLogLastError(wxT("PostMessage(WM_NULL)"));
 590             }
 591         }
 592     }
 593 }
 594
 595 // ----------------------------------------------------------------------------
 596 // other wxApp event hanlders
 597 // ----------------------------------------------------------------------------
 598
 599 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
 600 {
 601     // Windows will terminate the process soon after we return from
 602     // WM_ENDSESSION handler or when we delete our last window, so make sure we
 603     // at least execute our cleanup code before
 604
 605     // prevent the window from being destroyed when the corresponding wxTLW is
 606     // destroyed: this will result in a leak of a HWND, of course, but who
 607     // cares when the process is being killed anyhow
 608     if ( !wxTopLevelWindows.empty() )
 609         wxTopLevelWindows[0]->SetHWND(0);
 610
 611     const int rc = OnExit();
 612
 613     wxEntryCleanup();
 614
 615     // calling exit() instead of ExitProcess() or not doing anything at all and
 616     // being killed by Windows has the advantage of executing the dtors of
 617     // global objects
 618     exit(rc);
 619 }
 620
 621 // Default behaviour: close the application with prompts. The
 622 // user can veto the close, and therefore the end session.
 623 void wxApp::OnQueryEndSession(wxCloseEvent& event)
 624 {
 625     if (GetTopWindow())
 626     {
 627         if (!GetTopWindow()->Close(!event.CanVeto()))
 628             event.Veto(true);
 629     }
 630 }
 631
 632 // ----------------------------------------------------------------------------
 633 // system DLL versions
 634 // ----------------------------------------------------------------------------
 635
 636 // these functions have trivial inline implementations for CE
 637 #ifndef __WXWINCE__
 638
 639 #if wxUSE_DYNLIB_CLASS
 640
 641 namespace
 642 {
 643
 644 // helper function: retrieve the DLL version by using DllGetVersion(), returns
 645 // 0 if the DLL doesn't export such function
 646 int CallDllGetVersion(wxDynamicLibrary& dll)
 647 {
 648     // now check if the function is available during run-time
 649     wxDYNLIB_FUNCTION( DLLGETVERSIONPROC, DllGetVersion, dll );
 650     if ( !pfnDllGetVersion )
 651         return 0;
 652
 653     DLLVERSIONINFO dvi;
 654     dvi.cbSize = sizeof(dvi);
 655
 656     HRESULT hr = (*pfnDllGetVersion)(&dvi);
 657     if ( FAILED(hr) )
 658     {
 659         wxLogApiError(_T("DllGetVersion"), hr);
 660
 661         return 0;
 662     }
 663
 664     return 100*dvi.dwMajorVersion + dvi.dwMinorVersion;
 665 }
 666
 667 } // anonymous namespace
 668
 669 /* static */
 670 int wxApp::GetComCtl32Version()
 671 {
 672     // cache the result
 673     //
 674     // NB: this is MT-ok as in the worst case we'd compute s_verComCtl32 twice,
 675     //     but as its value should be the same both times it doesn't matter
 676     static int s_verComCtl32 = -1;
 677
 678     if ( s_verComCtl32 == -1 )
 679     {
 680         // we're prepared to handle the errors
 681         wxLogNull noLog;
 682
 683         // the DLL should really be available
 684         wxDynamicLibrary dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM);
 685         if ( !dllComCtl32.IsLoaded() )
 686         {
 687             s_verComCtl32 = 0;
 688             return 0;
 689         }
 690
 691         // try DllGetVersion() for recent DLLs
 692         s_verComCtl32 = CallDllGetVersion(dllComCtl32);
 693
 694         // if DllGetVersion() is unavailable either during compile or
 695         // run-time, try to guess the version otherwise
 696         if ( !s_verComCtl32 )
 697         {
 698             // InitCommonControlsEx is unique to 4.70 and later
 699             void *pfn = dllComCtl32.GetSymbol(_T("InitCommonControlsEx"));
 700             if ( !pfn )
 701             {
 702                 // not found, must be 4.00
 703                 s_verComCtl32 = 400;
 704             }
 705             else // 4.70+
 706             {
 707                 // many symbols appeared in comctl32 4.71, could use any of
 708                 // them except may be DllInstall()
 709                 pfn = dllComCtl32.GetSymbol(_T("InitializeFlatSB"));
 710                 if ( !pfn )
 711                 {
 712                     // not found, must be 4.70
 713                     s_verComCtl32 = 470;
 714                 }
 715                 else
 716                 {
 717                     // found, must be 4.71 or later
 718                     s_verComCtl32 = 471;
 719                 }
 720             }
 721         }
 722     }
 723
 724     return s_verComCtl32;
 725 }
 726
 727 /* static */
 728 int wxApp::GetShell32Version()
 729 {
 730     static int s_verShell32 = -1;
 731     if ( s_verShell32 == -1 )
 732     {
 733         // we're prepared to handle the errors
 734         wxLogNull noLog;
 735
 736         wxDynamicLibrary dllShell32(_T("shell32.dll"), wxDL_VERBATIM);
 737         if ( dllShell32.IsLoaded() )
 738         {
 739             s_verShell32 = CallDllGetVersion(dllShell32);
 740
 741             if ( !s_verShell32 )
 742             {
 743                 // there doesn't seem to be any way to distinguish between 4.00
 744                 // and 4.70 (starting from 4.71 we have DllGetVersion()) so
 745                 // just assume it is 4.0
 746                 s_verShell32 = 400;
 747             }
 748         }
 749         else // failed load the DLL?
 750         {
 751             s_verShell32 = 0;
 752         }
 753     }
 754
 755     return s_verShell32;
 756 }
 757
 758 #else // !wxUSE_DYNLIB_CLASS
 759
 760 /* static */
 761 int wxApp::GetComCtl32Version()
 762 {
 763     return 0;
 764 }
 765
 766 /* static */
 767 int wxApp::GetShell32Version()
 768 {
 769     return 0;
 770 }
 771
 772 #endif // wxUSE_DYNLIB_CLASS/!wxUSE_DYNLIB_CLASS
 773
 774 #endif // !__WXWINCE__
 775
 776 // ----------------------------------------------------------------------------
 777 // Yield to incoming messages
 778 // ----------------------------------------------------------------------------
 779
 780 bool wxApp::Yield(bool onlyIfNeeded)
 781 {
 782     // MT-FIXME
 783     static bool s_inYield = false;
 784
 785 #if wxUSE_LOG
 786     // disable log flushing from here because a call to wxYield() shouldn't
 787     // normally result in message boxes popping up &c
 788     wxLog::Suspend();
 789 #endif // wxUSE_LOG
 790
 791     if ( s_inYield )
 792     {
 793         if ( !onlyIfNeeded )
 794         {
 795             wxFAIL_MSG( wxT("wxYield called recursively" ) );
 796         }
 797
 798         return false;
 799     }
 800
 801     s_inYield = true;
 802
 803     // we don't want to process WM_QUIT from here - it should be processed in
 804     // the main event loop in order to stop it
 805     MSG msg;
 806     while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) &&
 807             msg.message != WM_QUIT )
 808     {
 809 #if wxUSE_THREADS
 810         wxMutexGuiLeaveOrEnter();
 811 #endif // wxUSE_THREADS
 812
 813         if ( !wxTheApp->Dispatch() )
 814             break;
 815     }
 816
 817     // if there are pending events, we must process them.
 818     ProcessPendingEvents();
 819
 820 #if wxUSE_LOG
 821     // let the logs be flashed again
 822     wxLog::Resume();
 823 #endif // wxUSE_LOG
 824
 825     s_inYield = false;
 826
 827     return true;
 828 }
 829
 830 #if wxUSE_EXCEPTIONS
 831
 832 // ----------------------------------------------------------------------------
 833 // exception handling
 834 // ----------------------------------------------------------------------------
 835
 836 bool wxApp::OnExceptionInMainLoop()
 837 {
 838     // ask the user about what to do: use the Win32 API function here as it
 839     // could be dangerous to use any wxWidgets code in this state
 840     switch (
 841             ::MessageBox
 842               (
 843                 NULL,
 844                 _T("An unhandled exception occurred. Press \"Abort\" to \
 845 terminate the program,\r\n\
 846 \"Retry\" to exit the program normally and \"Ignore\" to try to continue."),
 847                 _T("Unhandled exception"),
 848                 MB_ABORTRETRYIGNORE |
 849                 MB_ICONERROR|
 850                 MB_TASKMODAL
 851               )
 852            )
 853     {
 854         case IDABORT:
 855             throw;
 856
 857         default:
 858             wxFAIL_MSG( _T("unexpected MessageBox() return code") );
 859             // fall through
 860
 861         case IDRETRY:
 862             return false;
 863
 864         case IDIGNORE:
 865             return true;
 866     }
 867 }
 868
 869 #endif // wxUSE_EXCEPTIONS