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 wxTheApp;
 390     wxTheApp = NULL;
 391
 392 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 393     // At this point we want to check if there are any memory
 394     // blocks that aren't part of the wxDebugContext itself,
 395     // as a special case. Then when dumping we need to ignore
 396     // wxDebugContext, too.
 397     if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
 398     {
 399         wxLogDebug(wxT("There were memory leaks."));
 400         wxDebugContext::Dump();
 401         wxDebugContext::PrintStatistics();
 402     }
 403     //  wxDebugContext::SetStream(NULL, NULL);
 404 #endif
 405
 406 #if wxUSE_LOG
 407     // do it as the very last thing because everything else can log messages
 408     delete wxLog::SetActiveTarget(NULL);
 409 #endif // wxUSE_LOG
 410 } // end of wxApp::CleanUp
 411
 412 int wxEntry(
 413   int                               argc
 414 , char*                             argv[]
 415 )
 416 {
 417     HAB                             vHab = 0;
 418
 419     if (!wxApp::Initialize(vHab))
 420         return 0;
 421
 422     //
 423     // create the application object or ensure that one already exists
 424     //
 425     if (!wxTheApp)
 426     {
 427         // The app may have declared a global application object, but we recommend
 428         // the IMPLEMENT_APP macro is used instead, which sets an initializer
 429         // function for delayed, dynamic app object construction.
 430         wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
 431                      wxT("No initializer - use IMPLEMENT_APP macro.") );
 432         wxTheApp = (*wxApp::GetInitializerFunction()) ();
 433     }
 434     wxCHECK_MSG( wxTheApp, 0, wxT("You have to define an instance of wxApp!") );
 435     wxTheApp->argc = argc;
 436
 437 #if wxUSE_UNICODE
 438     wxTheApp->argv = new wxChar*[argc+1];
 439
 440     int                             nArgc = 0;
 441
 442     while (nArgc < argc)
 443     {
 444           wxTheApp->argv[nArgc] = wxStrdup(wxConvLibc.cMB2WX(argv[nArgc]));
 445           nArgc++;
 446     }
 447     wxTheApp->argv[nArgc] = (wxChar *)NULL;
 448 #else
 449     wxTheApp->argv = argv;
 450 #endif
 451
 452     wxString                        sName(wxFileNameFromPath(argv[0]));
 453
 454     wxStripExtension(sName);
 455     wxTheApp->SetAppName(sName);
 456
 457     int                             nRetValue = 0;
 458
 459     if (!wxTheApp->OnInitGui())
 460         nRetValue = -1;
 461
 462     if (nRetValue == 0)
 463     {
 464         if (wxTheApp->OnInit())
 465         {
 466             nRetValue = wxTheApp->OnRun();
 467 //          nRetValue = -1;
 468         }
 469     }
 470
 471     wxWindow*                       pTopWindow = wxTheApp->GetTopWindow();
 472
 473     if (pTopWindow)
 474     {
 475         // Forcibly delete the window.
 476         if (pTopWindow->IsKindOf(CLASSINFO(wxFrame)) ||
 477             pTopWindow->IsKindOf(CLASSINFO(wxDialog)) )
 478         {
 479             pTopWindow->Close(TRUE);
 480             wxTheApp->DeletePendingObjects();
 481         }
 482         else
 483         {
 484             delete pTopWindow;
 485             wxTheApp->SetTopWindow(NULL);
 486         }
 487     }
 488     wxTheApp->OnExit();
 489     wxApp::CleanUp();
 490     return(nRetValue);
 491 } // end of wxEntry
 492
 493 bool wxApp::OnInitGui()
 494 {
 495     ERRORID                         vError;
 496     wxString                        sError;
 497
 498     m_hMq = ::WinCreateMsgQueue(vHabmain, 0);
 499     if (!m_hMq)
 500     {
 501         vError = ::WinGetLastError(vHabmain);
 502         sError = wxPMErrorToStr(vError);
 503         wxLogDebug(sError);
 504         return FALSE;
 505     }
 506     return TRUE;
 507 } // end of wxApp::OnInitGui
 508
 509 //
 510 // Static member initialization
 511 //
 512 wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
 513
 514 wxApp::wxApp()
 515 {
 516     m_topWindow = NULL;
 517     wxTheApp = this;
 518     m_wantDebugOutput = TRUE;
 519
 520     argc = 0;
 521     argv = NULL;
 522     m_nPrintMode = wxPRINT_WINDOWS;
 523     m_exitOnFrameDelete = TRUE;
 524     m_bAuto3D = TRUE;
 525 } // end of wxApp::wxApp
 526
 527 wxApp::~wxApp()
 528 {
 529     //
 530     // Delete command-line args
 531     //
 532     int                             i;
 533
 534     for (i = 0; i < argc; i++)
 535     {
 536         delete[] argv[i];
 537     }
 538     delete[] argv;
 539 } // end of wxApp::~wxApp
 540
 541 bool wxApp::Initialized()
 542 {
 543     if (GetTopWindow())
 544         return TRUE;
 545     else
 546         return FALSE;
 547 } // end of wxApp::Initialized
 548
 549 //
 550 // Get and process a message, returning FALSE if WM_QUIT
 551 // received (and also set the flag telling the app to exit the main loop)
 552 //
 553 bool wxApp::DoMessage()
 554 {
 555     BOOL                            bRc = ::WinGetMsg(vHabmain, &m_vMsg, HWND(NULL), 0, 0);
 556
 557     if (bRc == 0)
 558     {
 559         // got WM_QUIT
 560         m_bKeepGoing = FALSE;
 561         return FALSE;
 562     }
 563     else if (bRc == -1)
 564     {
 565         // should never happen, but let's test for it nevertheless
 566         wxLogLastError("GetMessage");
 567     }
 568     else
 569     {
 570 #if wxUSE_THREADS
 571         wxASSERT_MSG( wxThread::IsMain()
 572                      ,wxT("only the main thread can process Windows messages")
 573                     );
 574
 575         static bool                 sbHadGuiLock = TRUE;
 576         static wxMsgArray           svSavedMessages;
 577
 578         //
 579         // If a secondary thread owns is doing GUI calls, save all messages for
 580         // later processing - we can't process them right now because it will
 581         // lead to recursive library calls (and we're not reentrant)
 582         //
 583         if (!wxGuiOwnedByMainThread())
 584         {
 585             sbHadGuiLock = FALSE;
 586
 587             //
 588             // Leave out WM_COMMAND messages: too dangerous, sometimes
 589             // the message will be processed twice
 590             //
 591             if ( !wxIsWaitingForThread() ||
 592                     svCurrentMsg.msg != WM_COMMAND )
 593             {
 594                 svSavedMessages.Add(svCurrentMsg);
 595             }
 596             return TRUE;
 597         }
 598         else
 599         {
 600             //
 601             // Have we just regained the GUI lock? if so, post all of the saved
 602             // messages
 603             //
 604             if (!sbHadGuiLock )
 605             {
 606                 sbHadGuiLock = TRUE;
 607
 608                 size_t             nCount = svSavedMessages.Count();
 609
 610                 for (size_t n = 0; n < nCount; n++)
 611                 {
 612                     QMSG            vMsg = svSavedMessages[n];
 613
 614                     if ( !ProcessMessage((WXMSG *)&vMsg) )
 615                     {
 616                         ::WinDispatchMsg(vHabmain, &vMsg);
 617                     }
 618                 }
 619                 svSavedMessages.Empty();
 620             }
 621         }
 622 #endif // wxUSE_THREADS
 623
 624         // Process the message
 625         if (!ProcessMessage((WXMSG *)&svCurrentMsg) )
 626         {
 627             ::WinDispatchMsg(vHabmain, (PQMSG)&svCurrentMsg);
 628         }
 629     }
 630     return TRUE;
 631 } // end of wxApp::DoMessage
 632
 633 //////////////////////////////////////////////////////////////////////////////
 634 //
 635 // Keep trying to process messages until WM_QUIT
 636 // received.
 637 //
 638 // If there are messages to be processed, they will all be
 639 // processed and OnIdle will not be called.
 640 // When there are no more messages, OnIdle is called.
 641 // If OnIdle requests more time,
 642 // it will be repeatedly called so long as there are no pending messages.
 643 // A 'feature' of this is that once OnIdle has decided that no more processing
 644 // is required, then it won't get processing time until further messages
 645 // are processed (it'll sit in DoMessage).
 646 //
 647 //////////////////////////////////////////////////////////////////////////////
 648 int wxApp::MainLoop()
 649 {
 650     m_bKeepGoing = TRUE;
 651
 652     while (m_bKeepGoing)
 653     {
 654 #if wxUSE_THREADS
 655         wxMutexGuiLeaveOrEnter();
 656 #endif // wxUSE_THREADS
 657         while (!Pending() && ProcessIdle())
 658         {
 659         }
 660         DoMessage();
 661     }
 662     return (int)svCurrentMsg.mp1;
 663 } // end of wxApp::MainLoop
 664
 665 //
 666 // Returns TRUE if more time is needed.
 667 //
 668 bool wxApp::ProcessIdle()
 669 {
 670     wxIdleEvent                     vEvent;
 671
 672     vEvent.SetEventObject(this);
 673     ProcessEvent(vEvent);
 674     return vEvent.MoreRequested();
 675 } // end of wxApp::ProcessIdle
 676
 677 void wxApp::ExitMainLoop()
 678 {
 679     m_bKeepGoing = FALSE;
 680 }
 681
 682 bool wxApp::Pending()
 683 {
 684     return (::WinPeekMsg(vHabmain, (PQMSG)&svCurrentMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) != 0);
 685 }
 686
 687 void wxApp::Dispatch()
 688 {
 689     DoMessage();
 690 }
 691
 692 //////////////////////////////////////////////////////////////////////////////
 693 //
 694 // Give all windows a chance to preprocess
 695 // the message. Some may have accelerator tables, or have
 696 // MDI complications.
 697 //
 698 //////////////////////////////////////////////////////////////////////////////
 699 bool wxApp::ProcessMessage(
 700   WXMSG*                            pWxmsg
 701 )
 702 {
 703     QMSG*                           vMsg = (PQMSG)pWxmsg;
 704     HWND                            hWnd = vMsg->hwnd;
 705     wxWindow*                       pWndThis = wxFindWinFromHandle((WXHWND)hWnd);
 706     wxWindow*                       pWnd;
 707
 708 #if wxUSE_TOOLTIPS
 709     //
 710     // We must relay WM_MOUSEMOVE events to the tooltip ctrl if we want it to
 711     // popup the tooltip bubbles
 712     //
 713     if (pWndThis && (vMsg->msg == WM_MOUSEMOVE))
 714     {
 715         wxToolTip*                  pToolTip = pWndThis->GetToolTip();
 716         if (pToolTip)
 717         {
 718             pToolTip->RelayEvent(pWxmsg);
 719         }
 720     }
 721 #endif // wxUSE_TOOLTIPS
 722
 723     //
 724     // For some composite controls (like a combobox), wndThis might be NULL
 725     // because the subcontrol is not a wxWindow, but only the control itself
 726     // is - try to catch this case
 727     //
 728     while (hWnd && !pWndThis)
 729     {
 730         hWnd = ::WinQueryWindow(hWnd, QW_PARENT);
 731         pWndThis = wxFindWinFromHandle((WXHWND)hWnd);
 732     }
 733
 734     //
 735     // Anyone for a non-translation message? Try youngest descendants first.
 736     //
 737     for (pWnd = pWndThis; pWnd; pWnd = pWnd->GetParent())
 738     {
 739         if (pWnd->OS2ProcessMessage(pWxmsg))
 740             return TRUE;
 741     }
 742     return FALSE;
 743 } // end of wxApp::ProcessMessage
 744
 745 void wxApp::OnIdle(
 746   wxIdleEvent&                      rEvent
 747 )
 748 {
 749     static bool                     sbInOnIdle = FALSE;
 750
 751     //
 752     // Avoid recursion (via ProcessEvent default case)
 753     //
 754     if (sbInOnIdle )
 755         return;
 756
 757     sbInOnIdle = TRUE;
 758
 759     //
 760     // If there are pending events, we must process them: pending events
 761     // are either events to the threads other than main or events posted
 762     // with wxPostEvent() functions
 763     //
 764     ProcessPendingEvents();
 765
 766     //
 767     // 'Garbage' collection of windows deleted with Close().
 768     //
 769     DeletePendingObjects();
 770
 771 #if wxUSE_LOG
 772     //
 773     // Flush the logged messages if any
 774     //
 775     wxLog::FlushActive();
 776 #endif // wxUSE_LOG
 777
 778     //
 779     // Send OnIdle events to all windows
 780     //
 781     if (SendIdleEvents())
 782     {
 783         //
 784         // SendIdleEvents() returns TRUE if at least one window requested more
 785         // idle events
 786         //
 787         rEvent.RequestMore(TRUE);
 788     }
 789     sbInOnIdle = FALSE;
 790 } // end of wxApp::OnIdle
 791
 792 // Send idle event to all top-level windows
 793 bool wxApp::SendIdleEvents()
 794 {
 795     bool                            bNeedMore = FALSE;
 796     wxWindowList::Node*             pNode = wxTopLevelWindows.GetFirst();
 797
 798     while (pNode)
 799     {
 800         wxWindow*                   pWin = pNode->GetData();
 801
 802         if (SendIdleEvents(pWin))
 803             bNeedMore = TRUE;
 804         pNode = pNode->GetNext();
 805     }
 806     return bNeedMore;
 807 } // end of wxApp::SendIdleEvents
 808
 809 //
 810 // Send idle event to window and all subwindows
 811 //
 812 bool wxApp::SendIdleEvents(
 813   wxWindow*                         pWin
 814 )
 815 {
 816     bool                            bNeedMore = FALSE;
 817     wxIdleEvent                     vEvent;
 818
 819     vEvent.SetEventObject(pWin);
 820     pWin->GetEventHandler()->ProcessEvent(vEvent);
 821
 822     if (vEvent.MoreRequested())
 823         bNeedMore = TRUE;
 824
 825     wxNode*                         pNode = pWin->GetChildren().First();
 826
 827     while (pNode)
 828     {
 829         wxWindow*                   pWin = (wxWindow*) pNode->Data();
 830
 831         if (SendIdleEvents(pWin))
 832             bNeedMore = TRUE;
 833         pNode = pNode->Next();
 834     }
 835     return bNeedMore;
 836 } // end of wxApp::SendIdleEvents
 837
 838 void wxApp::DeletePendingObjects()
 839 {
 840     wxNode*                         pNode = wxPendingDelete.First();
 841
 842     while (pNode)
 843     {
 844         wxObject*                   pObj = (wxObject *)pNode->Data();
 845
 846         delete pObj;
 847
 848         if (wxPendingDelete.Member(pObj))
 849             delete pNode;
 850
 851         //
 852         // Deleting one object may have deleted other pending
 853         // objects, so start from beginning of list again.
 854         //
 855         pNode = wxPendingDelete.First();
 856     }
 857 } // end of wxApp::DeletePendingObjects
 858
 859 void wxApp::OnEndSession(
 860   wxCloseEvent&                     WXUNUSED(rEvent))
 861 {
 862     if (GetTopWindow())
 863         GetTopWindow()->Close(TRUE);
 864 } // end of wxApp::OnEndSession
 865
 866 //
 867 // Default behaviour: close the application with prompts. The
 868 // user can veto the close, and therefore the end session.
 869 //
 870 void wxApp::OnQueryEndSession(
 871   wxCloseEvent&                     rEvent
 872 )
 873 {
 874     if (GetTopWindow())
 875     {
 876         if (!GetTopWindow()->Close(!rEvent.CanVeto()))
 877             rEvent.Veto(TRUE);
 878     }
 879 } // end of wxApp::OnQueryEndSession
 880
 881 void wxExit()
 882 {
 883     wxLogError(_("Fatal error: exiting"));
 884
 885     wxApp::CleanUp();
 886 } // end of wxExit
 887
 888 //
 889 // Yield to incoming messages
 890 //
 891 bool wxYield()
 892 {
 893     HAB                             vHab = 0;
 894     QMSG                            vMsg;
 895
 896     //
 897     // Disable log flushing from here because a call to wxYield() shouldn't
 898     // normally result in message boxes popping up &c
 899     //
 900     wxLog::Suspend();
 901
 902     //
 903     // We want to go back to the main message loop
 904     // if we see a WM_QUIT. (?)
 905     //
 906     while (::WinPeekMsg(vHab, &vMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) && vMsg.msg != WM_QUIT)
 907     {
 908 #if wxUSE_THREADS
 909         wxMutexGuiLeaveOrEnter();
 910 #endif // wxUSE_THREADS
 911         if (!wxTheApp->DoMessage())
 912             break;
 913     }
 914     //
 915     // If they are pending events, we must process them.
 916     //
 917     if (wxTheApp)
 918         wxTheApp->ProcessPendingEvents();
 919
 920     //
 921     // Let the logs be flashed again
 922     //
 923     wxLog::Resume();
 924     return TRUE;
 925 } // end of wxYield
 926
 927 wxIcon wxApp::GetStdIcon(
 928   int                               nWhich
 929 ) const
 930 {
 931     switch(nWhich)
 932     {
 933         case wxICON_INFORMATION:
 934             return wxIcon("wxICON_INFO");
 935
 936         case wxICON_QUESTION:
 937             return wxIcon("wxICON_QUESTION");
 938
 939         case wxICON_EXCLAMATION:
 940             return wxIcon("wxICON_WARNING");
 941
 942         default:
 943             wxFAIL_MSG(wxT("requested non existent standard icon"));
 944             // still fall through
 945
 946         case wxICON_HAND:
 947             return wxIcon("wxICON_ERROR");
 948     }
 949     return wxIcon("wxICON_ERROR");
 950 } // end of wxApp::GetStdIcon
 951
 952 //-----------------------------------------------------------------------------
 953 // wxWakeUpIdle
 954 //-----------------------------------------------------------------------------
 955
 956 void wxWakeUpIdle()
 957 {
 958     //
 959     // Send the top window a dummy message so idle handler processing will
 960     // start up again.  Doing it this way ensures that the idle handler
 961     // wakes up in the right thread (see also wxWakeUpMainThread() which does
 962     // the same for the main app thread only)
 963     //
 964     wxWindow*                       pTopWindow = wxTheApp->GetTopWindow();
 965
 966     if (pTopWindow)
 967     {
 968         if ( !::WinPostMsg(GetHwndOf(pTopWindow), WM_NULL, (MPARAM)0, (MPARAM)0))
 969         {
 970             //
 971             // Should never happen
 972             //
 973             wxLogLastError("PostMessage(WM_NULL)");
 974         }
 975     }
 976 } // end of wxWakeUpIdle
 977
 978 HAB wxGetInstance()
 979 {
 980     return vHabmain;
 981 }
 982
 983 void wxSetInstance(
 984   HAB                               vHab
 985 )
 986 {
 987     vHabmain = vHab;
 988 }
 989