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