src/os2/app.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        app.cpp
   3 // Purpose:     wxApp
   4 // Author:      David Webster
   5 // Modified by:
   6 // Created:     10/13/99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) David Webster
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifndef WX_PRECOMP
  16     #include "wx/frame.h"
  17     #include "wx/app.h"
  18     #include "wx/utils.h"
  19     #include "wx/gdicmn.h"
  20     #include "wx/pen.h"
  21     #include "wx/brush.h"
  22     #include "wx/cursor.h"
  23     #include "wx/icon.h"
  24     #include "wx/palette.h"
  25     #include "wx/dc.h"
  26     #include "wx/dialog.h"
  27     #include "wx/msgdlg.h"
  28     #include "wx/intl.h"
  29     #include "wx/dynarray.h"
  30 #   include "wx/wxchar.h"
  31 #   include "wx/icon.h"
  32 #endif
  33
  34 #include "wx/log.h"
  35 #include "wx/module.h"
  36
  37 #include "wx/os2/private.h"
  38
  39 #if wxUSE_THREADS
  40     #include "wx/thread.h"
  41
  42     // define the array of QMSG strutures
  43     WX_DECLARE_OBJARRAY(QMSG, wxMsgArray);
  44
  45     #include "wx/arrimpl.cpp"
  46
  47     WX_DEFINE_OBJARRAY(wxMsgArray);
  48 #endif // wxUSE_THREADS
  49
  50 #if wxUSE_WX_RESOURCES
  51     #include "wx/resource.h"
  52 #endif
  53
  54 #include <string.h>
  55 #include <ctype.h>
  56
  57 // ---------------------------------------------------------------------------
  58 // global variables
  59 // ---------------------------------------------------------------------------
  60
  61 extern wxChar*                      wxBuffer;
  62 extern wxChar*                      wxOsVersion;
  63 extern wxList*                      wxWinHandleList;
  64 extern wxList WXDLLEXPORT           wxPendingDelete;
  65 extern wxCursor*                    g_globalCursor;
  66
  67 HINSTANCE                           wxhInstance = 0;
  68 QMSG                                svCurrentMsg;
  69 wxApp*                              wxTheApp = NULL;
  70 HAB                                 vHabmain = NULL;
  71
  72 // FIXME why not const? and not static?
  73
  74 // NB: all "NoRedraw" classes must have the same names as the "normal" classes
  75 //     with NR suffix - wxWindow::OS2Create() supposes this
  76 wxChar wxFrameClassName[]                 = wxT("wxFrameClass");
  77 wxChar wxFrameClassNameNoRedraw[]         = wxT("wxFrameClassNR");
  78 wxChar wxMDIFrameClassName[]              = wxT("wxMDIFrameClass");
  79 wxChar wxMDIFrameClassNameNoRedraw[]      = wxT("wxMDIFrameClassNR");
  80 wxChar wxMDIChildFrameClassName[]         = wxT("wxMDIChildFrameClass");
  81 wxChar wxMDIChildFrameClassNameNoRedraw[] = wxT("wxMDIChildFrameClassNR");
  82 wxChar wxPanelClassName[]                 = wxT("wxPanelClass");
  83 wxChar wxCanvasClassName[]                = wxT("wxCanvasClass");
  84
  85 HICON wxSTD_FRAME_ICON          = (HICON) NULL;
  86 HICON wxSTD_MDICHILDFRAME_ICON  = (HICON) NULL;
  87 HICON wxSTD_MDIPARENTFRAME_ICON = (HICON) NULL;
  88
  89 HICON wxDEFAULT_FRAME_ICON           = (HICON) NULL;
  90 HICON wxDEFAULT_MDICHILDFRAME_ICON   = (HICON) NULL;
  91 HICON wxDEFAULT_MDIPARENTFRAME_ICON  = (HICON) NULL;
  92
  93 HBRUSH wxDisableButtonBrush = (HBRUSH) 0;
  94
  95 MRESULT EXPENTRY wxWndProc( HWND
  96                            ,ULONG
  97                            ,MPARAM
  98                            ,MPARAM
  99                           );
 100
 101 // ===========================================================================
 102 // implementation
 103 // ===========================================================================
 104
 105 // ---------------------------------------------------------------------------
 106 // wxApp
 107 // ---------------------------------------------------------------------------
 108
 109     IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
 110
 111     BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 112         EVT_IDLE(wxApp::OnIdle)
 113         EVT_END_SESSION(wxApp::OnEndSession)
 114         EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
 115     END_EVENT_TABLE()
 116
 117 //// Initialize
 118 bool wxApp::Initialize(
 119   HAB                               vHab
 120 )
 121 {
 122     //
 123     // OS2 has to have an anchorblock
 124     //
 125     vHab = WinInitialize(0);
 126
 127     if (!vHab)
 128         return FALSE;
 129     else
 130         vHabmain = vHab;
 131
 132     // Some people may wish to use this, but
 133     // probably it shouldn't be here by default.
 134 #ifdef __WXDEBUG__
 135     //    wxRedirectIOToConsole();
 136 #endif
 137
 138     wxBuffer = new wxChar[1500]; // FIXME; why?
 139
 140     wxClassInfo::InitializeClasses();
 141
 142 #if wxUSE_RESOURCES
 143     wxGetResource(wxT("wxWindows"), wxT("OsVersion"), &wxOsVersion);
 144 #endif
 145
 146     // I'm annoyed ... I don't know where to put this and I don't want to
 147     // create a module for that as it's part of the core.
 148     wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
 149     wxTheColourDatabase->Initialize();
 150
 151     wxInitializeStockLists();
 152     wxInitializeStockObjects();
 153
 154 #if wxUSE_WX_RESOURCES
 155     wxInitializeResourceSystem();
 156 #endif
 157
 158     wxBitmap::InitStandardHandlers();
 159
 160     g_globalCursor = new wxCursor;
 161
 162 #if 0
 163     wxSTD_FRAME_ICON = ::WinLoadFileIcon(wxT("wxSTD_FRAME"), TRUE);
 164     wxSTD_MDIPARENTFRAME_ICON = ::WinLoadFileIcon(wxT("wxSTD_MDIPARENTFRAME"), TRUE);
 165     wxSTD_MDICHILDFRAME_ICON = ::WinLoadFileIcon(wxT("wxSTD_MDICHILDFRAME"), TRUE);
 166
 167     wxDEFAULT_FRAME_ICON = ::WinLoadFileIcon(wxT("wxDEFAULT_FRAME"), TRUE);
 168     wxDEFAULT_MDIPARENTFRAME_ICON = ::WinLoadFileIcon(wxT("wxDEFAULT_MDIPARENTFRAME"), TRUE);
 169     wxDEFAULT_MDICHILDFRAME_ICON = ::WinLoadFileIcon(wxT("wxDEFAULT_MDICHILDFRAME"), TRUE);
 170 #endif
 171     RegisterWindowClasses(vHab);
 172     wxWinHandleList = new wxList(wxKEY_INTEGER);
 173
 174     // This is to foil optimizations in Visual C++ that throw out dummy.obj.
 175     // PLEASE DO NOT ALTER THIS.
 176 #if !defined(WXMAKINGDLL) && defined(__VISAGECPP__)
 177     extern char wxDummyChar;
 178     if (wxDummyChar) wxDummyChar++;
 179 #endif
 180
 181     // wxSetKeyboardHook(TRUE);
 182
 183     wxModule::RegisterModules();
 184     if (!wxModule::InitializeModules())
 185         return FALSE;
 186     return TRUE;
 187 }
 188
 189 // ---------------------------------------------------------------------------
 190 // RegisterWindowClasses
 191 // ---------------------------------------------------------------------------
 192
 193 // TODO we should only register classes really used by the app. For this it
 194 //      would be enough to just delay the class registration until an attempt
 195 //      to create a window of this class is made.
 196 bool wxApp::RegisterWindowClasses(
 197   HAB                               vHab
 198 )
 199 {
 200     APIRET                          rc;
 201     ERRORID                         vError = 0L;
 202     wxString                        sError;
 203
 204     if (!::WinRegisterClass( vHab
 205                             ,wxFrameClassName
 206                             ,(PFNWP)wxWndProc
 207                             ,CS_SIZEREDRAW | CS_SYNCPAINT
 208                             ,0
 209                            ))
 210     {
 211         vError = ::WinGetLastError(vHab);
 212         sError = wxPMErrorToStr(vError);
 213         wxLogLastError(sError);
 214         return FALSE;
 215     }
 216
 217     if (!::WinRegisterClass( vHab
 218                             ,wxFrameClassNameNoRedraw
 219                             ,(PFNWP)wxWndProc
 220                             ,0
 221                             ,0
 222                            ))
 223     {
 224         vError = ::WinGetLastError(vHab);
 225         sError = wxPMErrorToStr(vError);
 226         wxLogLastError(sError);
 227         return FALSE;
 228     }
 229
 230     if (!::WinRegisterClass( vHab
 231                             ,wxMDIFrameClassName
 232                             ,(PFNWP)wxWndProc
 233                             ,CS_SIZEREDRAW | CS_SYNCPAINT
 234                             ,0
 235                            ))
 236     {
 237         vError = ::WinGetLastError(vHab);
 238         sError = wxPMErrorToStr(vError);
 239         wxLogLastError(sError);
 240         return FALSE;
 241     }
 242
 243     if (!::WinRegisterClass( vHab
 244                             ,wxMDIFrameClassNameNoRedraw
 245                             ,(PFNWP)wxWndProc
 246                             ,0
 247                             ,0
 248                            ))
 249     {
 250         vError = ::WinGetLastError(vHab);
 251         sError = wxPMErrorToStr(vError);
 252         wxLogLastError(sError);
 253         return FALSE;
 254     }
 255
 256     if (!::WinRegisterClass( vHab
 257                             ,wxMDIChildFrameClassName
 258                             ,(PFNWP)wxWndProc
 259                             ,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_SYNCPAINT | CS_HITTEST
 260                             ,0
 261                            ))
 262     {
 263         vError = ::WinGetLastError(vHab);
 264         sError = wxPMErrorToStr(vError);
 265         wxLogLastError(sError);
 266         return FALSE;
 267     }
 268
 269     if (!::WinRegisterClass( vHab
 270                             ,wxMDIChildFrameClassNameNoRedraw
 271                             ,(PFNWP)wxWndProc
 272                             ,CS_HITTEST
 273                             ,0
 274                            ))
 275     {
 276         vError = ::WinGetLastError(vHab);
 277         sError = wxPMErrorToStr(vError);
 278         wxLogLastError(sError);
 279         return FALSE;
 280     }
 281
 282     if (!::WinRegisterClass( vHab
 283                             ,wxPanelClassName
 284                             ,(PFNWP)wxWndProc
 285                             ,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_HITTEST | CS_SAVEBITS | CS_SYNCPAINT
 286                             ,0
 287                            ))
 288     {
 289         vError = ::WinGetLastError(vHab);
 290         sError = wxPMErrorToStr(vError);
 291         wxLogLastError(sError);
 292         return FALSE;
 293     }
 294
 295     if (!::WinRegisterClass( vHab
 296                             ,wxCanvasClassName
 297                             ,(PFNWP)wxWndProc
 298                             ,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_HITTEST | CS_SAVEBITS | CS_SYNCPAINT
 299                             ,0
 300                            ))
 301     {
 302         vError = ::WinGetLastError(vHab);
 303         sError = wxPMErrorToStr(vError);
 304         wxLogLastError(sError);
 305         return FALSE;
 306     }
 307     return TRUE;
 308 }
 309
 310 //// Cleans up any wxWindows internal structures left lying around
 311
 312 void wxApp::CleanUp()
 313 {
 314     //// COMMON CLEANUP
 315
 316 #if wxUSE_LOG
 317     // flush the logged messages if any and install a 'safer' log target: the
 318     // default one (wxLogGui) can't be used after the resources are freed just
 319     // below and the user suppliedo ne might be even more unsafe (using any
 320     // wxWindows GUI function is unsafe starting from now)
 321     wxLog::DontCreateOnDemand();
 322
 323     // this will flush the old messages if any
 324 #if (!(defined(__VISAGECPP__) && __IBMCPP__ < 400))
 325     // another VA 3.0 memory problem here
 326     delete wxLog::SetActiveTarget(new wxLogStderr);
 327 #endif
 328 #endif // wxUSE_LOG
 329
 330     // One last chance for pending objects to be cleaned up
 331     wxTheApp->DeletePendingObjects();
 332
 333 #if (!(defined(__VISAGECPP__) && __IBMCPP__ < 400))
 334     // another VA 3.0 memory problem here
 335     wxModule::CleanUpModules();
 336 #endif
 337
 338 #if wxUSE_WX_RESOURCES
 339     wxCleanUpResourceSystem();
 340
 341     //  wxDefaultResourceTable->ClearTable();
 342 #endif
 343
 344     // Indicate that the cursor can be freed, so that cursor won't be deleted
 345     // by deleting the bitmap list before g_globalCursor goes out of scope
 346     // (double deletion of the cursor).
 347     wxSetCursor(wxNullCursor);
 348 #if (!(defined(__VISAGECPP__) && __IBMCPP__ < 400))
 349     // another VA 3.0 memory problem here
 350     delete g_globalCursor;
 351 #endif
 352     g_globalCursor = NULL;
 353
 354     wxDeleteStockObjects();
 355
 356     // Destroy all GDI lists, etc.
 357     wxDeleteStockLists();
 358
 359     delete wxTheColourDatabase;
 360     wxTheColourDatabase = NULL;
 361
 362     wxBitmap::CleanUpHandlers();
 363
 364     delete[] wxBuffer;
 365     wxBuffer = NULL;
 366
 367     //// WINDOWS-SPECIFIC CLEANUP
 368
 369     // wxSetKeyboardHook(FALSE);
 370
 371     if (wxSTD_FRAME_ICON)
 372         ::WinFreeFileIcon(wxSTD_FRAME_ICON);
 373     if (wxSTD_MDICHILDFRAME_ICON)
 374         ::WinFreeFileIcon(wxSTD_MDICHILDFRAME_ICON);
 375     if (wxSTD_MDIPARENTFRAME_ICON)
 376         ::WinFreeFileIcon(wxSTD_MDIPARENTFRAME_ICON);
 377
 378     if (wxDEFAULT_FRAME_ICON)
 379         ::WinFreeFileIcon(wxDEFAULT_FRAME_ICON);
 380     if (wxDEFAULT_MDICHILDFRAME_ICON)
 381         ::WinFreeFileIcon(wxDEFAULT_MDICHILDFRAME_ICON);
 382     if (wxDEFAULT_MDIPARENTFRAME_ICON)
 383         ::WinFreeFileIcon(wxDEFAULT_MDIPARENTFRAME_ICON);
 384
 385     if ( wxDisableButtonBrush )
 386     {
 387 // TODO:        ::DeleteObject( wxDisableButtonBrush );
 388     }
 389
 390     if (wxWinHandleList)
 391         delete wxWinHandleList;
 392
 393     // GL: I'm annoyed ... I don't know where to put this and I don't want to
 394     // create a module for that as it's part of the core.
 395 #if wxUSE_THREADS
 396     delete wxPendingEvents;
 397     delete wxPendingEventsLocker;
 398     // If we don't do the following, we get an apparent memory leak.
 399     ((wxEvtHandler&) wxDefaultValidator).ClearEventLocker();
 400 #endif
 401
 402     wxClassInfo::CleanUpClasses();
 403
 404     delete wxTheApp;
 405     wxTheApp = NULL;
 406
 407 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 408     // At this point we want to check if there are any memory
 409     // blocks that aren't part of the wxDebugContext itself,
 410     // as a special case. Then when dumping we need to ignore
 411     // wxDebugContext, too.
 412     if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
 413     {
 414         wxLogDebug(wxT("There were memory leaks."));
 415         wxDebugContext::Dump();
 416         wxDebugContext::PrintStatistics();
 417     }
 418     //  wxDebugContext::SetStream(NULL, NULL);
 419 #endif
 420
 421 #if wxUSE_LOG
 422     // do it as the very last thing because everything else can log messages
 423     delete wxLog::SetActiveTarget(NULL);
 424 #endif // wxUSE_LOG
 425 }
 426
 427 int wxEntry(
 428   int                               argc
 429 , char*                             argv[]
 430 )
 431 {
 432     HAB                             vHab = 0;
 433
 434     if (!wxApp::Initialize(vHab))
 435         return 0;
 436
 437     //
 438     // create the application object or ensure that one already exists
 439     //
 440     if (!wxTheApp)
 441     {
 442         // The app may have declared a global application object, but we recommend
 443         // the IMPLEMENT_APP macro is used instead, which sets an initializer
 444         // function for delayed, dynamic app object construction.
 445         wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
 446                      wxT("No initializer - use IMPLEMENT_APP macro.") );
 447         wxTheApp = (*wxApp::GetInitializerFunction()) ();
 448     }
 449     wxCHECK_MSG( wxTheApp, 0, wxT("You have to define an instance of wxApp!") );
 450     wxTheApp->argc = argc;
 451
 452 #if wxUSE_UNICODE
 453     wxTheApp->argv = new wxChar*[argc+1];
 454
 455     int                             nArgc = 0;
 456
 457     while (nArgc < argc)
 458     {
 459           wxTheApp->argv[nArgc] = wxStrdup(wxConvLibc.cMB2WX(argv[nArgc]));
 460           nArgc++;
 461     }
 462     wxTheApp->argv[nArgc] = (wxChar *)NULL;
 463 #else
 464     wxTheApp->argv = argv;
 465 #endif
 466
 467     wxString                        sName(wxFileNameFromPath(argv[0]));
 468
 469     wxStripExtension(sName);
 470     wxTheApp->SetAppName(sName);
 471
 472     int                             nRetValue = 0;
 473
 474     if (!wxTheApp->OnInitGui())
 475         nRetValue = -1;
 476
 477     if (nRetValue == 0)
 478     {
 479         if (wxTheApp->OnInit())
 480         {
 481             nRetValue = -1;
 482         }
 483     }
 484
 485     if (nRetValue == 0)
 486     {
 487         wxWindow*                   pTopWindow = wxTheApp->GetTopWindow();
 488
 489         if (pTopWindow)
 490         {
 491             // Forcibly delete the window.
 492             if (pTopWindow->IsKindOf(CLASSINFO(wxFrame)) ||
 493                 pTopWindow->IsKindOf(CLASSINFO(wxDialog)) )
 494             {
 495                 pTopWindow->Close(TRUE);
 496                 wxTheApp->DeletePendingObjects();
 497             }
 498             else
 499             {
 500                 delete pTopWindow;
 501                 wxTheApp->SetTopWindow(NULL);
 502             }
 503         }
 504     }
 505     wxTheApp->OnExit();
 506     wxApp::CleanUp();
 507     return(nRetValue);
 508 }
 509
 510 bool wxApp::OnInitGui()
 511 {
 512     ERRORID                         vError;
 513     wxString                        sError;
 514
 515     m_hMq = ::WinCreateMsgQueue(vHabmain, 0);
 516     if (!m_hMq)
 517     {
 518         vError = ::WinGetLastError(vHabmain);
 519         sError = wxPMErrorToStr(vError);
 520         wxLogDebug(sError);
 521         return FALSE;
 522     }
 523     return TRUE;
 524 }
 525
 526 //
 527 // Static member initialization
 528 //
 529 wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
 530
 531 wxApp::wxApp()
 532 {
 533     m_topWindow = NULL;
 534     wxTheApp = this;
 535     m_wantDebugOutput = TRUE;
 536
 537     argc = 0;
 538     argv = NULL;
 539     m_nPrintMode = wxPRINT_WINDOWS;
 540     m_exitOnFrameDelete = TRUE;
 541     m_bAuto3D = TRUE;
 542 }
 543
 544 wxApp::~wxApp()
 545 {
 546 #if wxUSE_UNICODE
 547     // Delete command-line args
 548     int i;
 549     for (i = 0; i < argc; i++)
 550     {
 551         delete[] argv[i];
 552     }
 553     delete[] argv;
 554 #endif
 555 }
 556
 557 bool wxApp::Initialized()
 558 {
 559     if (GetTopWindow())
 560         return TRUE;
 561     else
 562         return FALSE;
 563 }
 564
 565 //
 566 // Get and process a message, returning FALSE if WM_QUIT
 567 // received (and also set the flag telling the app to exit the main loop)
 568 //
 569 bool wxApp::DoMessage()
 570 {
 571     BOOL                            bRc = ::WinGetMsg(vHabmain, &m_vMsg, HWND(NULL), 0, 0);
 572
 573     if (bRc == 0)
 574     {
 575         // got WM_QUIT
 576         m_bKeepGoing = FALSE;
 577         return FALSE;
 578     }
 579     else if (bRc == -1)
 580     {
 581         // should never happen, but let's test for it nevertheless
 582         wxLogLastError("GetMessage");
 583     }
 584     else
 585     {
 586 #if wxUSE_THREADS
 587         wxASSERT_MSG( wxThread::IsMain()
 588                      ,wxT("only the main thread can process Windows messages")
 589                     );
 590
 591         static bool                 sbHadGuiLock = TRUE;
 592         static wxMsgArray           svSavedMessages;
 593
 594         //
 595         // if a secondary thread owns is doing GUI calls, save all messages for
 596         // later processing - we can't process them right now because it will
 597         // lead to recursive library calls (and we're not reentrant)
 598         //
 599         if (!wxGuiOwnedByMainThread())
 600         {
 601             sbHadGuiLock = FALSE;
 602
 603             // leave out WM_COMMAND messages: too dangerous, sometimes
 604             // the message will be processed twice
 605             if ( !wxIsWaitingForThread() ||
 606                     svCurrentMsg.msg != WM_COMMAND )
 607             {
 608                 svSavedMessages.Add(svCurrentMsg);
 609             }
 610             return TRUE;
 611         }
 612         else
 613         {
 614             //
 615             // have we just regained the GUI lock? if so, post all of the saved
 616             // messages
 617             //
 618             // FIXME of course, it's not _exactly_ the same as processing the
 619             //       messages normally - expect some things to break...
 620             //
 621             if (!sbHadGuiLock )
 622             {
 623                 sbHadGuiLock = TRUE;
 624
 625                 size_t             nCount = svSavedMessages.Count();
 626
 627                 for (size_t n = 0; n < nCount; n++)
 628                 {
 629                     QMSG            vMsg = svSavedMessages[n];
 630
 631                     if ( !ProcessMessage((WXMSG *)&vMsg) )
 632                     {
 633                         ::WinDispatchMsg(vHabmain, &vMsg);
 634                     }
 635                 }
 636                 svSavedMessages.Empty();
 637             }
 638         }
 639 #endif // wxUSE_THREADS
 640
 641         // Process the message
 642         if (!ProcessMessage((WXMSG *)&svCurrentMsg) )
 643         {
 644             ::WinDispatchMsg(vHabmain, (PQMSG)&svCurrentMsg);
 645         }
 646     }
 647     return TRUE;
 648 }
 649
 650 //////////////////////////////////////////////////////////////////////////////
 651 //
 652 // Keep trying to process messages until WM_QUIT
 653 // received.
 654 //
 655 // If there are messages to be processed, they will all be
 656 // processed and OnIdle will not be called.
 657 // When there are no more messages, OnIdle is called.
 658 // If OnIdle requests more time,
 659 // it will be repeatedly called so long as there are no pending messages.
 660 // A 'feature' of this is that once OnIdle has decided that no more processing
 661 // is required, then it won't get processing time until further messages
 662 // are processed (it'll sit in DoMessage).
 663 //
 664 //////////////////////////////////////////////////////////////////////////////
 665 int wxApp::MainLoop()
 666 {
 667     m_bKeepGoing = TRUE;
 668
 669     while (m_bKeepGoing)
 670     {
 671 #if wxUSE_THREADS
 672         wxMutexGuiLeaveOrEnter();
 673 #endif // wxUSE_THREADS
 674         while (!::WinPeekMsg(vHabmain, &svCurrentMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) &&
 675                 ProcessIdle() )
 676         {
 677         }
 678         DoMessage();
 679     }
 680     return (int)svCurrentMsg.mp1;
 681 }
 682
 683 //
 684 // Returns TRUE if more time is needed.
 685 //
 686 bool wxApp::ProcessIdle()
 687 {
 688     wxIdleEvent                     vEvent;
 689
 690     vEvent.SetEventObject(this);
 691     ProcessEvent(vEvent);
 692     return vEvent.MoreRequested();
 693 }
 694
 695 #if wxUSE_THREADS
 696 void wxApp::ProcessPendingEvents()
 697 {
 698     wxNode*                         pNode = wxPendingEvents->First();
 699     wxCriticalSectionLocker         vLocker(*wxPendingEventsLocker);
 700
 701     while (pNode)
 702     {
 703         wxEvtHandler*               pHandler = (wxEvtHandler *)pNode->Data();
 704         pHandler->ProcessPendingEvents();
 705
 706         delete pNode;
 707         pNode = wxPendingEvents->First();
 708     }
 709 }
 710 #endif
 711
 712 void wxApp::ExitMainLoop()
 713 {
 714     m_bKeepGoing = FALSE;
 715 }
 716
 717 bool wxApp::Pending()
 718 {
 719     return (::WinPeekMsg(vHabmain, (PQMSG)&svCurrentMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) != 0);
 720 }
 721
 722 void wxApp::Dispatch()
 723 {
 724     DoMessage();
 725 }
 726
 727 //////////////////////////////////////////////////////////////////////////////
 728 //
 729 // Give all windows a chance to preprocess
 730 // the message. Some may have accelerator tables, or have
 731 // MDI complications.
 732 //
 733 //////////////////////////////////////////////////////////////////////////////
 734 bool wxApp::ProcessMessage(
 735   WXMSG*                            pWxmsg
 736 )
 737 {
 738     QMSG*                           vMsg = (PQMSG)pWxmsg;
 739     HWND                            hWnd = vMsg->hwnd;
 740     wxWindow*                       pWndThis = wxFindWinFromHandle((WXHWND)hWnd);
 741     wxWindow*                       pWnd;
 742
 743     //
 744     // for some composite controls (like a combobox), wndThis might be NULL
 745     // because the subcontrol is not a wxWindow, but only the control itself
 746     // is - try to catch this case
 747     //
 748     while (hWnd && !pWndThis)
 749     {
 750         hWnd = ::WinQueryWindow(hWnd, QW_PARENT);
 751         pWndThis = wxFindWinFromHandle((WXHWND)hWnd);
 752     }
 753
 754     // Anyone for a non-translation message? Try youngest descendants first.
 755     for (pWnd = pWndThis; pWnd; pWnd = pWnd->GetParent())
 756     {
 757         if (pWnd->OS2ProcessMessage(pWxmsg))
 758             return TRUE;
 759     }
 760     return FALSE;
 761 }
 762
 763 void wxApp::OnIdle(
 764   wxIdleEvent&                      rEvent
 765 )
 766 {
 767     static bool                     sbInOnIdle = FALSE;
 768
 769     //
 770     // Avoid recursion (via ProcessEvent default case)
 771     //
 772     if (sbInOnIdle )
 773         return;
 774
 775     sbInOnIdle = TRUE;
 776
 777     //
 778     // 'Garbage' collection of windows deleted with Close().
 779     //
 780     DeletePendingObjects();
 781
 782 #if wxUSE_LOG
 783     // flush the logged messages if any
 784     wxLog*                          pLog = wxLog::GetActiveTarget();
 785
 786     if (pLog != NULL && pLog->HasPendingMessages())
 787         pLog->Flush();
 788 #endif // wxUSE_LOG
 789
 790     // Send OnIdle events to all windows
 791     if (SendIdleEvents())
 792     {
 793         //
 794         // SendIdleEvents() returns TRUE if at least one window requested more
 795         // idle events
 796         //
 797         rEvent.RequestMore(TRUE);
 798     }
 799
 800     //
 801     // If they are pending events, we must process them.
 802     //
 803 #if wxUSE_THREADS
 804     ProcessPendingEvents();
 805 #endif
 806     sbInOnIdle = FALSE;
 807 }
 808
 809 void wxWakeUpIdle()
 810 {
 811     // **** please implement me! ****
 812     // Wake up the idle handler processor, even if it is in another thread...
 813 }
 814
 815 // Send idle event to all top-level windows
 816 bool wxApp::SendIdleEvents()
 817 {
 818     bool                            bNeedMore = FALSE;
 819     wxWindowList::Node*             pNode = wxTopLevelWindows.GetFirst();
 820
 821     while (pNode)
 822     {
 823         wxWindow*                   pWin = pNode->GetData();
 824
 825         if (SendIdleEvents(pWin))
 826             bNeedMore = TRUE;
 827         pNode = pNode->GetNext();
 828     }
 829     return bNeedMore;
 830 }
 831
 832 //
 833 // Send idle event to window and all subwindows
 834 //
 835 bool wxApp::SendIdleEvents(
 836   wxWindow*                         pWin
 837 )
 838 {
 839     bool                            bNeedMore = FALSE;
 840     wxIdleEvent                     vEvent;
 841
 842     vEvent.SetEventObject(pWin);
 843     pWin->GetEventHandler()->ProcessEvent(vEvent);
 844
 845     if (vEvent.MoreRequested())
 846         bNeedMore = TRUE;
 847
 848     wxNode*                         pNode = pWin->GetChildren().First();
 849
 850     while (pNode)
 851     {
 852         wxWindow*                   pWin = (wxWindow*) pNode->Data();
 853
 854         if (SendIdleEvents(pWin))
 855             bNeedMore = TRUE;
 856         pNode = pNode->Next();
 857     }
 858     return bNeedMore;
 859 }
 860
 861 void wxApp::DeletePendingObjects()
 862 {
 863     wxNode*                         pNode = wxPendingDelete.First();
 864
 865     while (pNode)
 866     {
 867         wxObject*                   pObj = (wxObject *)pNode->Data();
 868
 869         delete pObj;
 870
 871         if (wxPendingDelete.Member(pObj))
 872             delete pNode;
 873
 874         //
 875         // Deleting one object may have deleted other pending
 876         // objects, so start from beginning of list again.
 877         //
 878         pNode = wxPendingDelete.First();
 879     }
 880 }
 881
 882 void wxApp::OnEndSession(
 883   wxCloseEvent&                     WXUNUSED(rEvent))
 884 {
 885     if (GetTopWindow())
 886         GetTopWindow()->Close(TRUE);
 887 }
 888
 889 //
 890 // Default behaviour: close the application with prompts. The
 891 // user can veto the close, and therefore the end session.
 892 //
 893 void wxApp::OnQueryEndSession(
 894   wxCloseEvent&                     rEvent
 895 )
 896 {
 897     if (GetTopWindow())
 898     {
 899         if (!GetTopWindow()->Close(!rEvent.CanVeto()))
 900             rEvent.Veto(TRUE);
 901     }
 902 }
 903
 904 void wxExit()
 905 {
 906     wxLogError(_("Fatal error: exiting"));
 907
 908     wxApp::CleanUp();
 909 }
 910
 911 // Yield to incoming messages
 912 bool wxYield()
 913 {
 914     HAB                             vHab = 0;
 915     QMSG                            vMsg;
 916     // We want to go back to the main message loop
 917     // if we see a WM_QUIT. (?)
 918     while (::WinPeekMsg(vHab, &vMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) && vMsg.msg != WM_QUIT)
 919     {
 920         if (!wxTheApp->DoMessage())
 921             break;
 922     }
 923     // If they are pending events, we must process them.
 924 #if wxUSE_THREADS
 925     wxTheApp->ProcessPendingEvents();
 926 #endif
 927     return TRUE;
 928 }
 929
 930 wxIcon wxApp::GetStdIcon(
 931   int                               nWhich
 932 ) const
 933 {
 934     switch(nWhich)
 935     {
 936         case wxICON_INFORMATION:
 937             return wxIcon("wxICON_INFO");
 938
 939         case wxICON_QUESTION:
 940             return wxIcon("wxICON_QUESTION");
 941
 942         case wxICON_EXCLAMATION:
 943             return wxIcon("wxICON_WARNING");
 944
 945         default:
 946             wxFAIL_MSG(wxT("requested non existent standard icon"));
 947             // still fall through
 948
 949         case wxICON_HAND:
 950             return wxIcon("wxICON_ERROR");
 951     }
 952     return wxIcon("wxICON_ERROR");
 953 }
 954
 955 HINSTANCE wxGetInstance()
 956 {
 957     return wxhInstance;
 958 }
 959
 960 void wxSetInstance(HINSTANCE hInst)
 961 {
 962     wxhInstance = hInst;
 963 }
 964