src/msw/app.cpp

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