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