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     wxWinHandleHash = new wxWinHashTable(wxKEY_INTEGER, 100);
 359
 360 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 361     wxSetKeyboardHook(true);
 362 #endif
 363
 364     callBaseCleanup.Dismiss();
 365
 366     return true;
 367 }
 368
 369 // ---------------------------------------------------------------------------
 370 // RegisterWindowClasses
 371 // ---------------------------------------------------------------------------
 372
 373 // TODO we should only register classes really used by the app. For this it
 374 //      would be enough to just delay the class registration until an attempt
 375 //      to create a window of this class is made.
 376 bool wxApp::RegisterWindowClasses()
 377 {
 378     WNDCLASS wndclass;
 379     wxZeroMemory(wndclass);
 380
 381     // for each class we register one with CS_(V|H)REDRAW style and one
 382     // without for windows created with wxNO_FULL_REDRAW_ON_REPAINT flag
 383     static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
 384     static const long styleNoRedraw = CS_DBLCLKS;
 385
 386     // the fields which are common to all classes
 387     wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
 388     wndclass.hInstance     = wxhInstance;
 389     wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
 390
 391     // register the class for all normal windows
 392     wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
 393     wndclass.lpszClassName = wxCanvasClassName;
 394     wndclass.style         = styleNormal;
 395
 396     if ( !RegisterClass(&wndclass) )
 397     {
 398         wxLogLastError(wxT("RegisterClass(frame)"));
 399     }
 400
 401     // "no redraw" frame
 402     wndclass.lpszClassName = wxCanvasClassNameNR;
 403     wndclass.style         = styleNoRedraw;
 404
 405     if ( !RegisterClass(&wndclass) )
 406     {
 407         wxLogLastError(wxT("RegisterClass(no redraw frame)"));
 408     }
 409
 410     // Register the MDI frame window class.
 411     wndclass.hbrBackground = (HBRUSH)NULL; // paint MDI frame ourselves
 412     wndclass.lpszClassName = wxMDIFrameClassName;
 413     wndclass.style         = styleNormal;
 414
 415     if ( !RegisterClass(&wndclass) )
 416     {
 417         wxLogLastError(wxT("RegisterClass(MDI parent)"));
 418     }
 419
 420     // "no redraw" MDI frame
 421     wndclass.lpszClassName = wxMDIFrameClassNameNoRedraw;
 422     wndclass.style         = styleNoRedraw;
 423
 424     if ( !RegisterClass(&wndclass) )
 425     {
 426         wxLogLastError(wxT("RegisterClass(no redraw MDI parent frame)"));
 427     }
 428
 429     // Register the MDI child frame window class.
 430     wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
 431     wndclass.lpszClassName = wxMDIChildFrameClassName;
 432     wndclass.style         = styleNormal;
 433
 434     if ( !RegisterClass(&wndclass) )
 435     {
 436         wxLogLastError(wxT("RegisterClass(MDI child)"));
 437     }
 438
 439     // "no redraw" MDI child frame
 440     wndclass.lpszClassName = wxMDIChildFrameClassNameNoRedraw;
 441     wndclass.style         = styleNoRedraw;
 442
 443     if ( !RegisterClass(&wndclass) )
 444     {
 445         wxLogLastError(wxT("RegisterClass(no redraw MDI child)"));
 446     }
 447
 448     return true;
 449 }
 450
 451 // ---------------------------------------------------------------------------
 452 // UnregisterWindowClasses
 453 // ---------------------------------------------------------------------------
 454
 455 bool wxApp::UnregisterWindowClasses()
 456 {
 457     bool retval = true;
 458
 459 #ifndef __WXMICROWIN__
 460     // MDI frame window class.
 461     if ( !::UnregisterClass(wxMDIFrameClassName, wxhInstance) )
 462     {
 463         wxLogLastError(wxT("UnregisterClass(MDI parent)"));
 464
 465         retval = false;
 466     }
 467
 468     // "no redraw" MDI frame
 469     if ( !::UnregisterClass(wxMDIFrameClassNameNoRedraw, wxhInstance) )
 470     {
 471         wxLogLastError(wxT("UnregisterClass(no redraw MDI parent frame)"));
 472
 473         retval = false;
 474     }
 475
 476     // MDI child frame window class.
 477     if ( !::UnregisterClass(wxMDIChildFrameClassName, wxhInstance) )
 478     {
 479         wxLogLastError(wxT("UnregisterClass(MDI child)"));
 480
 481         retval = false;
 482     }
 483
 484     // "no redraw" MDI child frame
 485     if ( !::UnregisterClass(wxMDIChildFrameClassNameNoRedraw, wxhInstance) )
 486     {
 487         wxLogLastError(wxT("UnregisterClass(no redraw MDI child)"));
 488
 489         retval = false;
 490     }
 491
 492     // canvas class name
 493     if ( !::UnregisterClass(wxCanvasClassName, wxhInstance) )
 494     {
 495         wxLogLastError(wxT("UnregisterClass(canvas)"));
 496
 497         retval = false;
 498     }
 499
 500     if ( !::UnregisterClass(wxCanvasClassNameNR, wxhInstance) )
 501     {
 502         wxLogLastError(wxT("UnregisterClass(no redraw canvas)"));
 503
 504         retval = false;
 505     }
 506 #endif // __WXMICROWIN__
 507
 508     return retval;
 509 }
 510
 511 void wxApp::CleanUp()
 512 {
 513     // all objects pending for deletion must be deleted first, otherwise we
 514     // would crash when they use wxWinHandleHash (and UnregisterWindowClasses()
 515     // call wouldn't succeed as long as any windows still exist), so call the
 516     // base class method first and only then do our clean up
 517     wxAppBase::CleanUp();
 518
 519 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
 520     wxSetKeyboardHook(false);
 521 #endif
 522
 523     wxOleUninitialize();
 524
 525     // for an EXE the classes are unregistered when it terminates but DLL may
 526     // be loaded several times (load/unload/load) into the same process in
 527     // which case the registration will fail after the first time if we don't
 528     // unregister the classes now
 529     UnregisterWindowClasses();
 530
 531     delete wxWinHandleHash;
 532     wxWinHandleHash = NULL;
 533
 534 #ifdef __WXWINCE__
 535     free( wxCanvasClassName );
 536     free( wxCanvasClassNameNR );
 537 #endif
 538 }
 539
 540 // ----------------------------------------------------------------------------
 541 // wxApp ctor/dtor
 542 // ----------------------------------------------------------------------------
 543
 544 wxApp::wxApp()
 545 {
 546     m_printMode = wxPRINT_WINDOWS;
 547 }
 548
 549 wxApp::~wxApp()
 550 {
 551 }
 552
 553 // ----------------------------------------------------------------------------
 554 // wxApp idle handling
 555 // ----------------------------------------------------------------------------
 556
 557 void wxApp::OnIdle(wxIdleEvent& WXUNUSED(event))
 558 {
 559 #if wxUSE_DC_CACHEING
 560     // automated DC cache management: clear the cached DCs and bitmap
 561     // if it's likely that the app has finished with them, that is, we
 562     // get an idle event and we're not dragging anything.
 563     if (!::GetKeyState(MK_LBUTTON) && !::GetKeyState(MK_MBUTTON) && !::GetKeyState(MK_RBUTTON))
 564         wxMSWDCImpl::ClearCache();
 565 #endif // wxUSE_DC_CACHEING
 566 }
 567
 568 void wxApp::WakeUpIdle()
 569 {
 570     // Send the top window a dummy message so idle handler processing will
 571     // start up again.  Doing it this way ensures that the idle handler
 572     // wakes up in the right thread (see also wxWakeUpMainThread() which does
 573     // the same for the main app thread only)
 574     wxWindow *topWindow = wxTheApp->GetTopWindow();
 575     if ( topWindow )
 576     {
 577         if ( !::PostMessage(GetHwndOf(topWindow), WM_NULL, 0, 0) )
 578         {
 579             // should never happen
 580             wxLogLastError(wxT("PostMessage(WM_NULL)"));
 581         }
 582     }
 583 }
 584
 585 // ----------------------------------------------------------------------------
 586 // other wxApp event hanlders
 587 // ----------------------------------------------------------------------------
 588
 589 void wxApp::OnEndSession(wxCloseEvent& WXUNUSED(event))
 590 {
 591     if (GetTopWindow())
 592         GetTopWindow()->Close(true);
 593 }
 594
 595 // Default behaviour: close the application with prompts. The
 596 // user can veto the close, and therefore the end session.
 597 void wxApp::OnQueryEndSession(wxCloseEvent& event)
 598 {
 599     if (GetTopWindow())
 600     {
 601         if (!GetTopWindow()->Close(!event.CanVeto()))
 602             event.Veto(true);
 603     }
 604 }
 605
 606 // ----------------------------------------------------------------------------
 607 // system DLL versions
 608 // ----------------------------------------------------------------------------
 609
 610 // these functions have trivial inline implementations for CE
 611 #ifndef __WXWINCE__
 612
 613 #if wxUSE_DYNLIB_CLASS
 614
 615 namespace
 616 {
 617
 618 // helper function: retrieve the DLL version by using DllGetVersion(), returns
 619 // 0 if the DLL doesn't export such function
 620 int CallDllGetVersion(wxDynamicLibrary& dll)
 621 {
 622     // now check if the function is available during run-time
 623     wxDYNLIB_FUNCTION( DLLGETVERSIONPROC, DllGetVersion, dll );
 624     if ( !pfnDllGetVersion )
 625         return 0;
 626
 627     DLLVERSIONINFO dvi;
 628     dvi.cbSize = sizeof(dvi);
 629
 630     HRESULT hr = (*pfnDllGetVersion)(&dvi);
 631     if ( FAILED(hr) )
 632     {
 633         wxLogApiError(_T("DllGetVersion"), hr);
 634
 635         return 0;
 636     }
 637
 638     return 100*dvi.dwMajorVersion + dvi.dwMinorVersion;
 639 }
 640
 641 } // anonymous namespace
 642
 643 /* static */
 644 int wxApp::GetComCtl32Version()
 645 {
 646     // cache the result
 647     //
 648     // NB: this is MT-ok as in the worst case we'd compute s_verComCtl32 twice,
 649     //     but as its value should be the same both times it doesn't matter
 650     static int s_verComCtl32 = -1;
 651
 652     if ( s_verComCtl32 == -1 )
 653     {
 654         // we're prepared to handle the errors
 655         wxLogNull noLog;
 656
 657         // the DLL should really be available
 658         wxDynamicLibrary dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM);
 659         if ( !dllComCtl32.IsLoaded() )
 660         {
 661             s_verComCtl32 = 0;
 662             return 0;
 663         }
 664
 665         // try DllGetVersion() for recent DLLs
 666         s_verComCtl32 = CallDllGetVersion(dllComCtl32);
 667
 668         // if DllGetVersion() is unavailable either during compile or
 669         // run-time, try to guess the version otherwise
 670         if ( !s_verComCtl32 )
 671         {
 672             // InitCommonControlsEx is unique to 4.70 and later
 673             void *pfn = dllComCtl32.GetSymbol(_T("InitCommonControlsEx"));
 674             if ( !pfn )
 675             {
 676                 // not found, must be 4.00
 677                 s_verComCtl32 = 400;
 678             }
 679             else // 4.70+
 680             {
 681                 // many symbols appeared in comctl32 4.71, could use any of
 682                 // them except may be DllInstall()
 683                 pfn = dllComCtl32.GetSymbol(_T("InitializeFlatSB"));
 684                 if ( !pfn )
 685                 {
 686                     // not found, must be 4.70
 687                     s_verComCtl32 = 470;
 688                 }
 689                 else
 690                 {
 691                     // found, must be 4.71 or later
 692                     s_verComCtl32 = 471;
 693                 }
 694             }
 695         }
 696     }
 697
 698     return s_verComCtl32;
 699 }
 700
 701 /* static */
 702 int wxApp::GetShell32Version()
 703 {
 704     static int s_verShell32 = -1;
 705     if ( s_verShell32 == -1 )
 706     {
 707         // we're prepared to handle the errors
 708         wxLogNull noLog;
 709
 710         wxDynamicLibrary dllShell32(_T("shell32.dll"), wxDL_VERBATIM);
 711         if ( dllShell32.IsLoaded() )
 712         {
 713             s_verShell32 = CallDllGetVersion(dllShell32);
 714
 715             if ( !s_verShell32 )
 716             {
 717                 // there doesn't seem to be any way to distinguish between 4.00
 718                 // and 4.70 (starting from 4.71 we have DllGetVersion()) so
 719                 // just assume it is 4.0
 720                 s_verShell32 = 400;
 721             }
 722         }
 723         else // failed load the DLL?
 724         {
 725             s_verShell32 = 0;
 726         }
 727     }
 728
 729     return s_verShell32;
 730 }
 731
 732 #else // !wxUSE_DYNLIB_CLASS
 733
 734 /* static */
 735 int wxApp::GetComCtl32Version()
 736 {
 737     return 0;
 738 }
 739
 740 /* static */
 741 int wxApp::GetShell32Version()
 742 {
 743     return 0;
 744 }
 745
 746 #endif // wxUSE_DYNLIB_CLASS/!wxUSE_DYNLIB_CLASS
 747
 748 #endif // !__WXWINCE__
 749
 750 // ----------------------------------------------------------------------------
 751 // Yield to incoming messages
 752 // ----------------------------------------------------------------------------
 753
 754 bool wxApp::Yield(bool onlyIfNeeded)
 755 {
 756     // MT-FIXME
 757     static bool s_inYield = false;
 758
 759 #if wxUSE_LOG
 760     // disable log flushing from here because a call to wxYield() shouldn't
 761     // normally result in message boxes popping up &c
 762     wxLog::Suspend();
 763 #endif // wxUSE_LOG
 764
 765     if ( s_inYield )
 766     {
 767         if ( !onlyIfNeeded )
 768         {
 769             wxFAIL_MSG( wxT("wxYield called recursively" ) );
 770         }
 771
 772         return false;
 773     }
 774
 775     s_inYield = true;
 776
 777     // we don't want to process WM_QUIT from here - it should be processed in
 778     // the main event loop in order to stop it
 779     MSG msg;
 780     while ( PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE) &&
 781             msg.message != WM_QUIT )
 782     {
 783 #if wxUSE_THREADS
 784         wxMutexGuiLeaveOrEnter();
 785 #endif // wxUSE_THREADS
 786
 787         if ( !wxTheApp->Dispatch() )
 788             break;
 789     }
 790
 791     // if there are pending events, we must process them.
 792     ProcessPendingEvents();
 793
 794 #if wxUSE_LOG
 795     // let the logs be flashed again
 796     wxLog::Resume();
 797 #endif // wxUSE_LOG
 798
 799     s_inYield = false;
 800
 801     return true;
 802 }
 803
 804 #if wxUSE_EXCEPTIONS
 805
 806 // ----------------------------------------------------------------------------
 807 // exception handling
 808 // ----------------------------------------------------------------------------
 809
 810 bool wxApp::OnExceptionInMainLoop()
 811 {
 812     // ask the user about what to do: use the Win32 API function here as it
 813     // could be dangerous to use any wxWidgets code in this state
 814     switch (
 815             ::MessageBox
 816               (
 817                 NULL,
 818                 _T("An unhandled exception occurred. Press \"Abort\" to \
 819 terminate the program,\r\n\
 820 \"Retry\" to exit the program normally and \"Ignore\" to try to continue."),
 821                 _T("Unhandled exception"),
 822                 MB_ABORTRETRYIGNORE |
 823                 MB_ICONERROR|
 824                 MB_TASKMODAL
 825               )
 826            )
 827     {
 828         case IDABORT:
 829             throw;
 830
 831         default:
 832             wxFAIL_MSG( _T("unexpected MessageBox() return code") );
 833             // fall through
 834
 835         case IDRETRY:
 836             return false;
 837
 838         case IDIGNORE:
 839             return true;
 840     }
 841 }
 842
 843 #endif // wxUSE_EXCEPTIONS