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     #include "wx/timer.h"
  33 #endif
  34
  35 #include "wx/log.h"
  36 #include "wx/module.h"
  37
  38 #include "wx/os2/private.h"
  39
  40 #ifdef __EMX__
  41
  42 #include <sys\ioctl.h>
  43 #include <sys\select.h>
  44
  45 #else
  46
  47 #include <nerrno.h>
  48 #include <ioctl.h>
  49 #include <select.h>
  50
  51 #endif // ndef for __EMX__
  52
  53 #ifndef __EMX__
  54
  55 #define select(a,b,c,d,e) bsdselect(a,b,c,d,e)
  56 int _System bsdselect(int,
  57                       struct fd_set *,
  58                       struct fd_set *,
  59                       struct fd_set *,
  60                       struct timeval *);
  61
  62 #endif
  63
  64 #if wxUSE_THREADS
  65     #include "wx/thread.h"
  66
  67     // define the array of QMSG strutures
  68     WX_DECLARE_OBJARRAY(QMSG, wxMsgArray);
  69
  70     #include "wx/arrimpl.cpp"
  71
  72     WX_DEFINE_OBJARRAY(wxMsgArray);
  73 #endif // wxUSE_THREADS
  74
  75 #if wxUSE_WX_RESOURCES
  76     #include "wx/resource.h"
  77 #endif
  78
  79 #if wxUSE_TOOLTIPS
  80     #include "wx/tooltip.h"
  81 #endif // wxUSE_TOOLTIPS
  82
  83 #include <string.h>
  84 #include <ctype.h>
  85
  86 // ---------------------------------------------------------------------------
  87 // global variables
  88 // ---------------------------------------------------------------------------
  89
  90 extern wxChar*                      wxBuffer;
  91 extern wxList*                      wxWinHandleList;
  92 extern wxList WXDLLEXPORT           wxPendingDelete;
  93 extern wxCursor*                    g_globalCursor;
  94
  95 HAB                                 vHabmain = NULLHANDLE;
  96 QMSG                                svCurrentMsg;
  97 wxApp*                              wxTheApp = NULL;
  98
  99 // NB: all "NoRedraw" classes must have the same names as the "normal" classes
 100 //     with NR suffix - wxWindow::OS2Create() supposes this
 101 wxChar wxFrameClassName[]                 = wxT("wxFrameClass");
 102 wxChar wxFrameClassNameNoRedraw[]         = wxT("wxFrameClassNR");
 103 wxChar wxMDIFrameClassName[]              = wxT("wxMDIFrameClass");
 104 wxChar wxMDIFrameClassNameNoRedraw[]      = wxT("wxMDIFrameClassNR");
 105 wxChar wxMDIChildFrameClassName[]         = wxT("wxMDIChildFrameClass");
 106 wxChar wxMDIChildFrameClassNameNoRedraw[] = wxT("wxMDIChildFrameClassNR");
 107 wxChar wxPanelClassName[]                 = wxT("wxPanelClass");
 108 wxChar wxCanvasClassName[]                = wxT("wxCanvasClass");
 109
 110 HICON wxSTD_FRAME_ICON          = (HICON) NULL;
 111 HICON wxSTD_MDICHILDFRAME_ICON  = (HICON) NULL;
 112 HICON wxSTD_MDIPARENTFRAME_ICON = (HICON) NULL;
 113
 114 HICON wxDEFAULT_FRAME_ICON           = (HICON) NULL;
 115 HICON wxDEFAULT_MDICHILDFRAME_ICON   = (HICON) NULL;
 116 HICON wxDEFAULT_MDIPARENTFRAME_ICON  = (HICON) NULL;
 117
 118 HBRUSH wxDisableButtonBrush = (HBRUSH) 0;
 119
 120 MRESULT EXPENTRY wxWndProc( HWND hWnd,ULONG message,MPARAM mp1,MPARAM mp2);
 121 MRESULT EXPENTRY wxFrameWndProc( HWND hWnd,ULONG message,MPARAM mp1,MPARAM mp2);
 122
 123 // ===========================================================================
 124 // implementation
 125 // ===========================================================================
 126
 127 // ---------------------------------------------------------------------------
 128 // helper struct and functions for socket handling
 129 // ---------------------------------------------------------------------------
 130
 131 struct GsocketCallbackInfo{
 132     void (*proc)(void *);
 133     int type;
 134     int handle;
 135     void* gsock;
 136 };
 137
 138 // These defines and wrapper functions are used here and in gsockpm.c
 139 #define wxSockReadMask  0x01
 140 #define wxSockWriteMask 0x02
 141
 142 #ifdef __EMX__
 143 extern "C"
 144 int wxAppAddSocketHandler(int handle, int mask,
 145                            void (*callback)(void*), void * gsock)
 146 {
 147     return wxTheApp->AddSocketHandler(handle, mask, callback, gsock);
 148 }
 149 extern "C"
 150 void wxAppRemoveSocketHandler(int handle)
 151 {
 152     wxTheApp->RemoveSocketHandler(handle);
 153 }
 154 #else
 155 //  Linkage mode problems using callbacks with extern C in a .cpp module
 156 int wxAppAddSocketHandler(int handle, int mask,
 157                            void (*callback)(void*), void * gsock)
 158 {
 159     return wxTheApp->AddSocketHandler(handle, mask, callback, gsock);
 160 }
 161 void wxAppRemoveSocketHandler(int handle)
 162 {
 163     wxTheApp->RemoveSocketHandler(handle);
 164 }
 165 #endif
 166
 167 void wxApp::HandleSockets()
 168 {
 169     bool pendingEvent = FALSE;
 170
 171     // Check whether it's time for Gsocket operation
 172     if (m_maxSocketHandles > 0 && m_maxSocketNr > 0)
 173     {
 174         fd_set readfds = m_readfds;
 175         fd_set writefds = m_writefds;
 176         struct timeval timeout;
 177         int i;
 178         struct GsocketCallbackInfo
 179           *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
 180         int r = 0;
 181         timeout.tv_sec = 0;
 182         timeout.tv_usec = 0;
 183         if ( select(m_maxSocketNr, &readfds, &writefds, 0, &timeout) > 0)
 184         {
 185             for (i = m_lastUsedHandle + 1; i != m_lastUsedHandle; i++)
 186             {
 187                 if (i == m_maxSocketNr)
 188                     i = 0;
 189                 if (FD_ISSET(i, &readfds))
 190                 {
 191                     int r;
 192                     for (r = 0; r < m_maxSocketHandles; r++){
 193                         if(CallbackInfo[r].handle == i &&
 194                            CallbackInfo[r].type == wxSockReadMask)
 195                             break;
 196                     }
 197                     if (r < m_maxSocketHandles)
 198                     {
 199                         CallbackInfo[r].proc(CallbackInfo[r].gsock);
 200                         pendingEvent = TRUE;
 201                         wxYield();
 202                     }
 203                 }
 204                 if (FD_ISSET(i, &writefds))
 205                 {
 206                     int r;
 207                     for (r = 0; r < m_maxSocketHandles; r++)
 208                         if(CallbackInfo[r].handle == i &&
 209                            CallbackInfo[r].type == wxSockWriteMask)
 210                             break;
 211                     if (r < m_maxSocketHandles)
 212                     {
 213                         CallbackInfo[r].proc(CallbackInfo[r].gsock);
 214                         pendingEvent = TRUE;
 215                         wxYield();
 216                     }
 217                 }
 218             }
 219             m_lastUsedHandle = i;
 220         }
 221         if (pendingEvent)
 222             wxYield();
 223     }
 224 }
 225 // ---------------------------------------------------------------------------
 226 // wxApp
 227 // ---------------------------------------------------------------------------
 228
 229     IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
 230
 231     BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 232         EVT_IDLE(wxApp::OnIdle)
 233         EVT_END_SESSION(wxApp::OnEndSession)
 234         EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
 235     END_EVENT_TABLE()
 236
 237 //
 238 // Initialize
 239 //
 240 bool wxApp::Initialize(
 241   HAB                               vHab
 242 )
 243 {
 244 #if defined(wxUSE_CONSOLEDEBUG)
 245   #if wxUSE_CONSOLEDEBUG
 246 /***********************************************/
 247 /* Code for using stdout debug                 */
 248 /* To use it you mast link app as "Window" - EK*/
 249 /***********************************************/
 250   {
 251      PPIB pib;
 252      PTIB tib;
 253
 254     printf("In console\n");
 255
 256   DosGetInfoBlocks(&tib, &pib);
 257 /* Try morphing into a PM application. */
 258 //  if(pib->pib_ultype == 2)    /* VIO */
 259     pib->pib_ultype = 3;
 260    }
 261 /**********************************************/
 262 /**********************************************/
 263   #endif //wxUSE_CONSOLEDEBUG
 264 #endif
 265
 266     //
 267     // OS2 has to have an anchorblock
 268     //
 269     vHab = WinInitialize(0);
 270
 271     if (!vHab)
 272         return FALSE;
 273     else
 274         vHabmain = vHab;
 275
 276     // Some people may wish to use this, but
 277     // probably it shouldn't be here by default.
 278 #ifdef __WXDEBUG__
 279     //    wxRedirectIOToConsole();
 280 #endif
 281
 282     wxBuffer = new wxChar[1500]; // FIXME; why?
 283
 284     wxClassInfo::InitializeClasses();
 285
 286 #if wxUSE_THREADS
 287     wxPendingEventsLocker = new wxCriticalSection;
 288 #endif
 289
 290     wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
 291     wxTheColourDatabase->Initialize();
 292
 293     wxInitializeStockLists();
 294     wxInitializeStockObjects();
 295
 296 #if wxUSE_WX_RESOURCES
 297     wxInitializeResourceSystem();
 298 #endif
 299
 300     wxBitmap::InitStandardHandlers();
 301
 302     RegisterWindowClasses(vHab);
 303     wxWinHandleList = new wxList(wxKEY_INTEGER);
 304
 305     // This is to foil optimizations in Visual C++ that throw out dummy.obj.
 306     // PLEASE DO NOT ALTER THIS.
 307 #if !defined(WXMAKINGDLL) && defined(__VISAGECPP__)
 308     extern char wxDummyChar;
 309     if (wxDummyChar) wxDummyChar++;
 310 #endif
 311
 312     // wxSetKeyboardHook(TRUE);
 313
 314     wxModule::RegisterModules();
 315     if (!wxModule::InitializeModules())
 316         return FALSE;
 317     return TRUE;
 318 } // end of wxApp::Initialize
 319
 320 const char*                         CANTREGISTERCLASS = " Can't register Class ";
 321 // ---------------------------------------------------------------------------
 322 // RegisterWindowClasses
 323 // ---------------------------------------------------------------------------
 324
 325 bool wxApp::RegisterWindowClasses(
 326   HAB                               vHab
 327 )
 328 {
 329     APIRET                          rc;
 330     ERRORID                         vError = 0L;
 331     wxString                        sError;
 332
 333     if (!::WinRegisterClass( vHab
 334                             ,wxFrameClassName
 335                             ,wxFrameWndProc
 336                             ,CS_SIZEREDRAW | CS_MOVENOTIFY | CS_SYNCPAINT  | CS_CLIPCHILDREN
 337                             ,sizeof(ULONG)
 338                            ))
 339     {
 340         vError = ::WinGetLastError(vHab);
 341         sError = wxPMErrorToStr(vError);
 342         wxLogLastError(sError);
 343         return FALSE;
 344     }
 345
 346     if (!::WinRegisterClass( vHab
 347                             ,wxFrameClassNameNoRedraw
 348                             ,wxWndProc
 349                             ,0
 350                             ,sizeof(ULONG)
 351                            ))
 352     {
 353         vError = ::WinGetLastError(vHab);
 354         sError = wxPMErrorToStr(vError);
 355         wxLogLastError(sError);
 356         return FALSE;
 357     }
 358
 359     if (!::WinRegisterClass( vHab
 360                             ,wxMDIFrameClassName
 361                             ,wxWndProc
 362                             ,CS_SIZEREDRAW | CS_MOVENOTIFY | CS_SYNCPAINT
 363                             ,sizeof(ULONG)
 364                            ))
 365     {
 366         vError = ::WinGetLastError(vHab);
 367         sError = wxPMErrorToStr(vError);
 368         wxLogLastError(sError);
 369         return FALSE;
 370     }
 371
 372     if (!::WinRegisterClass( vHab
 373                             ,wxMDIFrameClassNameNoRedraw
 374                             ,wxWndProc
 375                             ,0
 376                             ,sizeof(ULONG)
 377                            ))
 378     {
 379         vError = ::WinGetLastError(vHab);
 380         sError = wxPMErrorToStr(vError);
 381         wxLogLastError(sError);
 382         return FALSE;
 383     }
 384
 385     if (!::WinRegisterClass( vHab
 386                             ,wxMDIChildFrameClassName
 387                             ,wxWndProc
 388                             ,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_SYNCPAINT | CS_HITTEST
 389                             ,sizeof(ULONG)
 390                            ))
 391     {
 392         vError = ::WinGetLastError(vHab);
 393         sError = wxPMErrorToStr(vError);
 394         wxLogLastError(sError);
 395         return FALSE;
 396     }
 397
 398     if (!::WinRegisterClass( vHab
 399                             ,wxMDIChildFrameClassNameNoRedraw
 400                             ,wxWndProc
 401                             ,CS_HITTEST
 402                             ,sizeof(ULONG)
 403                            ))
 404     {
 405         vError = ::WinGetLastError(vHab);
 406         sError = wxPMErrorToStr(vError);
 407         wxLogLastError(sError);
 408         return FALSE;
 409     }
 410
 411     if (!::WinRegisterClass( vHab
 412                             ,wxPanelClassName
 413                             ,wxWndProc
 414                             ,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_HITTEST | CS_SAVEBITS | CS_SYNCPAINT
 415                             ,sizeof(ULONG)
 416                            ))
 417     {
 418         vError = ::WinGetLastError(vHab);
 419         sError = wxPMErrorToStr(vError);
 420         wxLogLastError(sError);
 421         return FALSE;
 422     }
 423
 424     if (!::WinRegisterClass( vHab
 425                             ,wxCanvasClassName
 426                             ,wxWndProc
 427                             ,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_HITTEST | CS_SAVEBITS | CS_SYNCPAINT | CS_CLIPCHILDREN
 428                             ,sizeof(ULONG)
 429                            ))
 430     {
 431         vError = ::WinGetLastError(vHab);
 432         sError = wxPMErrorToStr(vError);
 433         wxLogLastError(sError);
 434         return FALSE;
 435     }
 436     return TRUE;
 437 } // end of wxApp::RegisterWindowClasses
 438
 439 //
 440 // Cleans up any wxWindows internal structures left lying around
 441 //
 442 void wxApp::CleanUp()
 443 {
 444     //
 445     // COMMON CLEANUP
 446     //
 447
 448 #if wxUSE_LOG
 449
 450     //
 451     // Flush the logged messages if any and install a 'safer' log target: the
 452     // default one (wxLogGui) can't be used after the resources are freed just
 453     // below and the user suppliedo ne might be even more unsafe (using any
 454     // wxWindows GUI function is unsafe starting from now)
 455     //
 456     wxLog::DontCreateOnDemand();
 457
 458     //
 459     // This will flush the old messages if any
 460     //
 461     delete wxLog::SetActiveTarget(new wxLogStderr);
 462 #endif // wxUSE_LOG
 463
 464     //
 465     // One last chance for pending objects to be cleaned up
 466     //
 467     wxTheApp->DeletePendingObjects();
 468
 469     wxModule::CleanUpModules();
 470
 471 #if wxUSE_WX_RESOURCES
 472     wxCleanUpResourceSystem();
 473 #endif
 474
 475     wxDeleteStockObjects();
 476
 477     //
 478     // Destroy all GDI lists, etc.
 479     //
 480     wxDeleteStockLists();
 481
 482     delete wxTheColourDatabase;
 483     wxTheColourDatabase = NULL;
 484
 485     wxBitmap::CleanUpHandlers();
 486
 487     delete[] wxBuffer;
 488     wxBuffer = NULL;
 489
 490     //
 491     // PM-SPECIFIC CLEANUP
 492     //
 493
 494     // wxSetKeyboardHook(FALSE);
 495
 496     if (wxSTD_FRAME_ICON)
 497         ::WinFreeFileIcon(wxSTD_FRAME_ICON);
 498     if (wxSTD_MDICHILDFRAME_ICON)
 499         ::WinFreeFileIcon(wxSTD_MDICHILDFRAME_ICON);
 500     if (wxSTD_MDIPARENTFRAME_ICON)
 501         ::WinFreeFileIcon(wxSTD_MDIPARENTFRAME_ICON);
 502
 503     if (wxDEFAULT_FRAME_ICON)
 504         ::WinFreeFileIcon(wxDEFAULT_FRAME_ICON);
 505     if (wxDEFAULT_MDICHILDFRAME_ICON)
 506         ::WinFreeFileIcon(wxDEFAULT_MDICHILDFRAME_ICON);
 507     if (wxDEFAULT_MDIPARENTFRAME_ICON)
 508         ::WinFreeFileIcon(wxDEFAULT_MDIPARENTFRAME_ICON);
 509
 510     if ( wxDisableButtonBrush )
 511     {
 512 // TODO:        ::DeleteObject( wxDisableButtonBrush );
 513     }
 514
 515     if (wxWinHandleList)
 516         delete wxWinHandleList;
 517
 518     delete wxPendingEvents;
 519 #if wxUSE_THREADS
 520     delete wxPendingEventsLocker;
 521     // If we don't do the following, we get an apparent memory leak.
 522     ((wxEvtHandler&) wxDefaultValidator).ClearEventLocker();
 523 #endif
 524
 525     wxClassInfo::CleanUpClasses();
 526
 527     // Delete Message queue
 528     if (wxTheApp->m_hMq)
 529         ::WinDestroyMsgQueue(wxTheApp->m_hMq);
 530
 531     delete wxTheApp;
 532     wxTheApp = NULL;
 533
 534 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
 535     // At this point we want to check if there are any memory
 536     // blocks that aren't part of the wxDebugContext itself,
 537     // as a special case. Then when dumping we need to ignore
 538     // wxDebugContext, too.
 539     if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
 540     {
 541         wxLogDebug(wxT("There were memory leaks."));
 542         wxDebugContext::Dump();
 543         wxDebugContext::PrintStatistics();
 544     }
 545     //  wxDebugContext::SetStream(NULL, NULL);
 546 #endif
 547
 548 #if wxUSE_LOG
 549     // do it as the very last thing because everything else can log messages
 550     delete wxLog::SetActiveTarget(NULL);
 551 #endif // wxUSE_LOG
 552 } // end of wxApp::CleanUp
 553
 554 //----------------------------------------------------------------------
 555 // Main wxWindows entry point
 556 //----------------------------------------------------------------------
 557 int wxEntry(
 558   int                               argc
 559 , char*                             argv[]
 560 )
 561 {
 562     HAB                             vHab = 0;
 563
 564     if (!wxApp::Initialize(vHab))
 565         return 0;
 566
 567     //
 568     // create the application object or ensure that one already exists
 569     //
 570     if (!wxTheApp)
 571     {
 572         // The app may have declared a global application object, but we recommend
 573         // the IMPLEMENT_APP macro is used instead, which sets an initializer
 574         // function for delayed, dynamic app object construction.
 575         wxCHECK_MSG( wxApp::GetInitializerFunction(), 0,
 576                      wxT("No initializer - use IMPLEMENT_APP macro.") );
 577         wxTheApp = (*wxApp::GetInitializerFunction()) ();
 578     }
 579     wxCHECK_MSG( wxTheApp, 0, wxT("You have to define an instance of wxApp!") );
 580     wxTheApp->argc = argc;
 581
 582 #if wxUSE_UNICODE
 583     wxTheApp->argv = new wxChar*[argc+1];
 584
 585     int                             nArgc = 0;
 586
 587     while (nArgc < argc)
 588     {
 589           wxTheApp->argv[nArgc] = wxStrdup(wxConvLibc.cMB2WX(argv[nArgc]));
 590           nArgc++;
 591     }
 592     wxTheApp->argv[nArgc] = (wxChar *)NULL;
 593 #else
 594     wxTheApp->argv = argv;
 595 #endif
 596
 597     wxString                        sName(wxFileNameFromPath(argv[0]));
 598
 599     wxStripExtension(sName);
 600     wxTheApp->SetAppName(sName);
 601
 602     int                             nRetValue = 0;
 603
 604     if (!wxTheApp->OnInitGui())
 605         nRetValue = -1;
 606
 607     if (nRetValue == 0)
 608     {
 609         if (wxTheApp->OnInit())
 610         {
 611             nRetValue = wxTheApp->OnRun();
 612         }
 613         // Normal exit
 614         wxWindow*                   pTopWindow = wxTheApp->GetTopWindow();
 615         if (pTopWindow)
 616         {
 617             // Forcibly delete the window.
 618             if (pTopWindow->IsKindOf(CLASSINFO(wxFrame)) ||
 619                 pTopWindow->IsKindOf(CLASSINFO(wxDialog)) )
 620             {
 621                 pTopWindow->Close(TRUE);
 622                 wxTheApp->DeletePendingObjects();
 623             }
 624             else
 625             {
 626                 delete pTopWindow;
 627                 wxTheApp->SetTopWindow(NULL);
 628             }
 629         }
 630     }
 631     else // app initialization failed
 632     {
 633         wxLogLastError(" Gui initialization failed, exitting");
 634     }
 635 #if wxUSE_CONSOLEDEBUG
 636     printf("wxTheApp->OnExit ");
 637     fflush(stdout);
 638 #endif
 639     wxTheApp->OnExit();
 640 #if wxUSE_CONSOLEDEBUG
 641     printf("wxApp::CleanUp ");
 642     fflush(stdout);
 643 #endif
 644     wxApp::CleanUp();
 645 #if wxUSE_CONSOLEDEBUG
 646     printf("return %i ", nRetValue);
 647     fflush(stdout);
 648 #endif
 649     return(nRetValue);
 650 } // end of wxEntry
 651
 652 bool wxApp::OnInitGui()
 653 {
 654     ERRORID                         vError;
 655     wxString                        sError;
 656
 657     m_hMq = ::WinCreateMsgQueue(vHabmain, 0);
 658     if (!m_hMq)
 659     {
 660         vError = ::WinGetLastError(vHabmain);
 661         sError = wxPMErrorToStr(vError);
 662         wxLogDebug(sError);
 663         return FALSE;
 664     }
 665     return TRUE;
 666 } // end of wxApp::OnInitGui
 667
 668 //
 669 // Static member initialization
 670 //
 671 wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
 672
 673 wxApp::wxApp()
 674 {
 675     m_topWindow = NULL;
 676     wxTheApp = this;
 677     m_wantDebugOutput = TRUE;
 678
 679     argc = 0;
 680     argv = NULL;
 681     m_nPrintMode = wxPRINT_WINDOWS;
 682     m_exitOnFrameDelete = TRUE;
 683     m_bAuto3D = TRUE;
 684     m_hMq = 0;
 685     m_maxSocketHandles = 0;
 686     m_maxSocketNr = 0;
 687     m_sockCallbackInfo = 0;
 688 } // end of wxApp::wxApp
 689
 690 wxApp::~wxApp()
 691 {
 692     //
 693     // Delete command-line args
 694     //
 695 #if wxUSE_UNICODE
 696     int                             i;
 697
 698     for (i = 0; i < argc; i++)
 699     {
 700         delete[] argv[i];
 701     }
 702     delete[] argv;
 703 #endif
 704 } // end of wxApp::~wxApp
 705
 706 bool wxApp::Initialized()
 707 {
 708     if (GetTopWindow())
 709         return TRUE;
 710     else
 711         return FALSE;
 712 } // end of wxApp::Initialized
 713
 714 //
 715 // Get and process a message, returning FALSE if WM_QUIT
 716 // received (and also set the flag telling the app to exit the main loop)
 717 //
 718
 719 bool wxApp::DoMessage()
 720 {
 721     BOOL                            bRc = ::WinGetMsg(vHabmain, &svCurrentMsg, HWND(NULL), 0, 0);
 722
 723     if (bRc == 0)
 724     {
 725         // got WM_QUIT
 726         m_bKeepGoing = FALSE;
 727         return FALSE;
 728     }
 729     else if (bRc == -1)
 730     {
 731         // should never happen, but let's test for it nevertheless
 732         wxLogLastError("GetMessage");
 733     }
 734     else
 735     {
 736 #if wxUSE_THREADS
 737         wxASSERT_MSG( wxThread::IsMain()
 738                      ,wxT("only the main thread can process Windows messages")
 739                     );
 740
 741         static bool                 sbHadGuiLock = TRUE;
 742         static wxMsgArray           svSavedMessages;
 743
 744         //
 745         // If a secondary thread owns is doing GUI calls, save all messages for
 746         // later processing - we can't process them right now because it will
 747         // lead to recursive library calls (and we're not reentrant)
 748         //
 749         if (!wxGuiOwnedByMainThread())
 750         {
 751             sbHadGuiLock = FALSE;
 752
 753             //
 754             // Leave out WM_COMMAND messages: too dangerous, sometimes
 755             // the message will be processed twice
 756             //
 757             if ( !wxIsWaitingForThread() ||
 758                     svCurrentMsg.msg != WM_COMMAND )
 759             {
 760                 svSavedMessages.Add(svCurrentMsg);
 761             }
 762             return TRUE;
 763         }
 764         else
 765         {
 766             //
 767             // Have we just regained the GUI lock? if so, post all of the saved
 768             // messages
 769             //
 770             if (!sbHadGuiLock )
 771             {
 772                 sbHadGuiLock = TRUE;
 773
 774                 size_t             nCount = svSavedMessages.Count();
 775
 776                 for (size_t n = 0; n < nCount; n++)
 777                 {
 778                     QMSG            vMsg = svSavedMessages[n];
 779
 780                     if ( !ProcessMessage((WXMSG *)&vMsg) )
 781                     {
 782                         ::WinDispatchMsg(vHabmain, &vMsg);
 783                     }
 784                 }
 785                 svSavedMessages.Empty();
 786             }
 787         }
 788 #endif // wxUSE_THREADS
 789
 790         // Process the message
 791         if (!ProcessMessage((WXMSG *)&svCurrentMsg))
 792         {
 793             ::WinDispatchMsg(vHabmain, (PQMSG)&svCurrentMsg);
 794         }
 795     }
 796     return TRUE;
 797 } // end of wxApp::DoMessage
 798
 799 //////////////////////////////////////////////////////////////////////////////
 800 //
 801 // Keep trying to process messages until WM_QUIT
 802 // received.
 803 //
 804 // If there are messages to be processed, they will all be
 805 // processed and OnIdle will not be called.
 806 // When there are no more messages, OnIdle is called.
 807 // If OnIdle requests more time,
 808 // it will be repeatedly called so long as there are no pending messages.
 809 // A 'feature' of this is that once OnIdle has decided that no more processing
 810 // is required, then it won't get processing time until further messages
 811 // are processed (it'll sit in DoMessage).
 812 //
 813 //////////////////////////////////////////////////////////////////////////////
 814 int wxApp::MainLoop()
 815 {
 816     m_bKeepGoing = TRUE;
 817
 818     while (m_bKeepGoing)
 819     {
 820 #if wxUSE_THREADS
 821         wxMutexGuiLeaveOrEnter();
 822 #endif // wxUSE_THREADS
 823         while (!Pending() && ProcessIdle())
 824         {
 825             HandleSockets();
 826             wxUsleep(10000);
 827         }
 828         HandleSockets();
 829         if (Pending())
 830             DoMessage();
 831         else
 832             wxUsleep(10000);
 833
 834     }
 835     return (int)svCurrentMsg.mp1;
 836 } // end of wxApp::MainLoop
 837
 838 //
 839 // Returns TRUE if more time is needed.
 840 //
 841 bool wxApp::ProcessIdle()
 842 {
 843     wxIdleEvent                     vEvent;
 844
 845     vEvent.SetEventObject(this);
 846     ProcessEvent(vEvent);
 847     return vEvent.MoreRequested();
 848 } // end of wxApp::ProcessIdle
 849
 850 void wxApp::ExitMainLoop()
 851 {
 852     m_bKeepGoing = FALSE;
 853 }
 854
 855 bool wxApp::Pending()
 856 {
 857     return (::WinPeekMsg(vHabmain, (PQMSG)&svCurrentMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) != 0);
 858 }
 859
 860 void wxApp::Dispatch()
 861 {
 862     DoMessage();
 863 }
 864
 865 //////////////////////////////////////////////////////////////////////////////
 866 //
 867 // Give all windows a chance to preprocess
 868 // the message. Some may have accelerator tables, or have
 869 // MDI complications.
 870 //
 871 //////////////////////////////////////////////////////////////////////////////
 872 bool wxApp::ProcessMessage(
 873   WXMSG*                            pWxmsg
 874 )
 875 {
 876     QMSG*                           pMsg = (PQMSG)pWxmsg;
 877     HWND                            hWnd = pMsg->hwnd;
 878     wxWindow*                       pWndThis = wxFindWinFromHandle((WXHWND)hWnd);
 879     wxWindow*                       pWnd;
 880
 881 #if wxUSE_TOOLTIPS
 882     //
 883     // We must relay WM_MOUSEMOVE events to the tooltip ctrl if we want it to
 884     // popup the tooltip bubbles
 885     //
 886     if (pWndThis && (pMsg->msg == WM_MOUSEMOVE))
 887     {
 888         wxToolTip*                  pToolTip = pWndThis->GetToolTip();
 889         if (pToolTip)
 890         {
 891             pToolTip->RelayEvent(pWxmsg);
 892         }
 893     }
 894 #endif // wxUSE_TOOLTIPS
 895
 896     //
 897     // We must relay Timer events to wxTimer's processing function
 898     //
 899     if (pMsg->msg == WM_TIMER)
 900         wxTimerProc(NULL, 0, (int)pMsg->mp1, 0);
 901
 902     //
 903     // For some composite controls (like a combobox), wndThis might be NULL
 904     // because the subcontrol is not a wxWindow, but only the control itself
 905     // is - try to catch this case
 906     //
 907     while (hWnd && !pWndThis)
 908     {
 909         hWnd = ::WinQueryWindow(hWnd, QW_PARENT);
 910         pWndThis = wxFindWinFromHandle((WXHWND)hWnd);
 911     }
 912
 913     //
 914     // Try translations first; find the youngest window with
 915     // a translation table. OS/2 has case sensative accels, so
 916     // this block, coded by BK, removes that and helps make them
 917     // case insensative.
 918     //
 919     if(pMsg->msg == WM_CHAR)
 920     {
 921        PBYTE                        pChmsg = (PBYTE)&(pMsg->msg);
 922        USHORT                       uSch  = CHARMSG(pChmsg)->chr;
 923        bool                         bRc;
 924
 925        //
 926        // Do not process keyup events
 927        //
 928        if(!(CHARMSG(pChmsg)->fs & KC_KEYUP))
 929        {
 930            if((CHARMSG(pChmsg)->fs & (KC_ALT | KC_CTRL)) && CHARMSG(pChmsg)->chr != 0)
 931                 CHARMSG(pChmsg)->chr = (USHORT)wxToupper((UCHAR)uSch);
 932
 933
 934            for(pWnd = pWndThis; pWnd; pWnd = pWnd->GetParent() )
 935            {
 936                if((bRc = pWnd->OS2TranslateMessage(pWxmsg)) == TRUE)
 937                    break;
 938            }
 939
 940             if(!bRc)    // untranslated, should restore original value
 941                 CHARMSG(pChmsg)->chr = uSch;
 942         }
 943     }
 944     //
 945     // Anyone for a non-translation message? Try youngest descendants first.
 946     //
 947 //  for (pWnd = pWndThis; pWnd; pWnd = pWnd->GetParent())
 948 //  {
 949 //      if (pWnd->OS2ProcessMessage(pWxmsg))
 950 //          return TRUE;
 951 //  }
 952     return FALSE;
 953 } // end of wxApp::ProcessMessage
 954
 955 void wxApp::OnIdle(
 956   wxIdleEvent&                      rEvent
 957 )
 958 {
 959     static bool                     sbInOnIdle = FALSE;
 960
 961     //
 962     // Avoid recursion (via ProcessEvent default case)
 963     //
 964     if (sbInOnIdle)
 965         return;
 966
 967     sbInOnIdle = TRUE;
 968
 969     //
 970     // If there are pending events, we must process them: pending events
 971     // are either events to the threads other than main or events posted
 972     // with wxPostEvent() functions
 973     //
 974     ProcessPendingEvents();
 975
 976     //
 977     // 'Garbage' collection of windows deleted with Close().
 978     //
 979     DeletePendingObjects();
 980
 981 #if wxUSE_LOG
 982     //
 983     // Flush the logged messages if any
 984     //
 985     wxLog::FlushActive();
 986 #endif // wxUSE_LOG
 987
 988     //
 989     // Send OnIdle events to all windows
 990     //
 991     if (SendIdleEvents())
 992     {
 993         //
 994         // SendIdleEvents() returns TRUE if at least one window requested more
 995         // idle events
 996         //
 997         rEvent.RequestMore(TRUE);
 998     }
 999     sbInOnIdle = FALSE;
1000 } // end of wxApp::OnIdle
1001
1002 // Send idle event to all top-level windows
1003 bool wxApp::SendIdleEvents()
1004 {
1005     bool                            bNeedMore = FALSE;
1006     wxWindowList::Node*             pNode = wxTopLevelWindows.GetFirst();
1007
1008     while (pNode)
1009     {
1010         wxWindow*                   pWin = pNode->GetData();
1011
1012         if (SendIdleEvents(pWin))
1013             bNeedMore = TRUE;
1014         pNode = pNode->GetNext();
1015     }
1016     return bNeedMore;
1017 } // end of wxApp::SendIdleEvents
1018
1019 //
1020 // Send idle event to window and all subwindows
1021 //
1022 bool wxApp::SendIdleEvents(
1023   wxWindow*                         pWin
1024 )
1025 {
1026     bool                            bNeedMore = FALSE;
1027     wxIdleEvent                     vEvent;
1028
1029     vEvent.SetEventObject(pWin);
1030     pWin->GetEventHandler()->ProcessEvent(vEvent);
1031
1032     if (vEvent.MoreRequested())
1033         bNeedMore = TRUE;
1034
1035     wxNode*                         pNode = pWin->GetChildren().First();
1036
1037     while (pNode)
1038     {
1039         wxWindow*                   pWin = (wxWindow*) pNode->Data();
1040
1041         if (SendIdleEvents(pWin))
1042             bNeedMore = TRUE;
1043         pNode = pNode->Next();
1044     }
1045     return bNeedMore;
1046 } // end of wxApp::SendIdleEvents
1047
1048 void wxApp::DeletePendingObjects()
1049 {
1050     wxNode*                         pNode = wxPendingDelete.First();
1051
1052     while (pNode)
1053     {
1054         wxObject*                   pObj = (wxObject *)pNode->Data();
1055
1056         delete pObj;
1057
1058         if (wxPendingDelete.Member(pObj))
1059             delete pNode;
1060
1061         //
1062         // Deleting one object may have deleted other pending
1063         // objects, so start from beginning of list again.
1064         //
1065         pNode = wxPendingDelete.First();
1066     }
1067 } // end of wxApp::DeletePendingObjects
1068
1069 void wxApp::OnEndSession(
1070   wxCloseEvent&                     WXUNUSED(rEvent))
1071 {
1072     if (GetTopWindow())
1073         GetTopWindow()->Close(TRUE);
1074 } // end of wxApp::OnEndSession
1075
1076 //
1077 // Default behaviour: close the application with prompts. The
1078 // user can veto the close, and therefore the end session.
1079 //
1080 void wxApp::OnQueryEndSession(
1081   wxCloseEvent&                     rEvent
1082 )
1083 {
1084     if (GetTopWindow())
1085     {
1086         if (!GetTopWindow()->Close(!rEvent.CanVeto()))
1087             rEvent.Veto(TRUE);
1088     }
1089 } // end of wxApp::OnQueryEndSession
1090
1091 void wxExit()
1092 {
1093     wxLogError(_("Fatal error: exiting"));
1094
1095     wxApp::CleanUp();
1096 } // end of wxExit
1097
1098 static bool gs_inYield = FALSE;
1099
1100 //
1101 // Yield to incoming messages
1102 //
1103 bool wxYield()
1104 {
1105     HAB                             vHab = 0;
1106     QMSG                            vMsg;
1107
1108     //
1109     // Disable log flushing from here because a call to wxYield() shouldn't
1110     // normally result in message boxes popping up &c
1111     //
1112     wxLog::Suspend();
1113
1114     gs_inYield = TRUE;
1115
1116     //
1117     // We want to go back to the main message loop
1118     // if we see a WM_QUIT. (?)
1119     //
1120     while (::WinPeekMsg(vHab, &vMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) && vMsg.msg != WM_QUIT)
1121     {
1122 #if wxUSE_THREADS
1123         wxMutexGuiLeaveOrEnter();
1124 #endif // wxUSE_THREADS
1125         if (!wxTheApp->DoMessage())
1126             break;
1127     }
1128     //
1129     // If they are pending events, we must process them.
1130     //
1131     if (wxTheApp)
1132         wxTheApp->ProcessPendingEvents();
1133
1134     //
1135     // Let the logs be flashed again
1136     //
1137     wxLog::Resume();
1138     gs_inYield = FALSE;
1139     return TRUE;
1140 } // end of wxYield
1141
1142 // Yield to incoming messages; but fail silently if recursion is detected.
1143 bool wxYieldIfNeeded()
1144 {
1145     if (gs_inYield)
1146         return FALSE;
1147
1148     return wxYield();
1149 }
1150
1151 wxIcon wxApp::GetStdIcon(
1152   int                               nWhich
1153 ) const
1154 {
1155     switch(nWhich)
1156     {
1157         case wxICON_INFORMATION:
1158             return wxIcon("wxICON_INFO");
1159
1160         case wxICON_QUESTION:
1161             return wxIcon("wxICON_QUESTION");
1162
1163         case wxICON_EXCLAMATION:
1164             return wxIcon("wxICON_WARNING");
1165
1166         default:
1167             wxFAIL_MSG(wxT("requested non existent standard icon"));
1168             // still fall through
1169
1170         case wxICON_HAND:
1171             return wxIcon("wxICON_ERROR");
1172     }
1173     return wxIcon("wxICON_ERROR");
1174 } // end of wxApp::GetStdIcon
1175
1176 int wxApp::AddSocketHandler(int handle, int mask,
1177                             void (*callback)(void*), void * gsock)
1178 {
1179     int find;
1180     struct GsocketCallbackInfo
1181         *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
1182
1183     for (find = 0; find < m_maxSocketHandles; find++)
1184         if (CallbackInfo[find].handle == -1)
1185             break;
1186     if (find == m_maxSocketHandles)
1187     {
1188         // Allocate new memory
1189         m_sockCallbackInfo = realloc(m_sockCallbackInfo,
1190                                      (m_maxSocketHandles+=10)*
1191                                      sizeof(struct GsocketCallbackInfo));
1192         CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
1193         for (find = m_maxSocketHandles - 10; find < m_maxSocketHandles; find++)
1194             CallbackInfo[find].handle = -1;
1195         find = m_maxSocketHandles - 10;
1196     }
1197     CallbackInfo[find].proc = callback;
1198     CallbackInfo[find].type = mask;
1199     CallbackInfo[find].handle = handle;
1200     CallbackInfo[find].gsock = gsock;
1201     if (mask & wxSockReadMask)
1202         FD_SET(handle, &m_readfds);
1203     if (mask & wxSockWriteMask)
1204         FD_SET(handle, &m_writefds);
1205     if (handle >= m_maxSocketNr)
1206         m_maxSocketNr = handle + 1;
1207     return find;
1208 }
1209
1210 void wxApp::RemoveSocketHandler(int handle)
1211 {
1212     struct GsocketCallbackInfo
1213         *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
1214     if (handle < m_maxSocketHandles)
1215     {
1216         if (CallbackInfo[handle].type & wxSockReadMask)
1217             FD_CLR(CallbackInfo[handle].handle, &m_readfds);
1218         if (CallbackInfo[handle].type & wxSockWriteMask)
1219             FD_CLR(CallbackInfo[handle].handle, &m_writefds);
1220         CallbackInfo[handle].handle = -1;
1221     }
1222 }
1223
1224 //-----------------------------------------------------------------------------
1225 // wxWakeUpIdle
1226 //-----------------------------------------------------------------------------
1227
1228 void wxWakeUpIdle()
1229 {
1230     //
1231     // Send the top window a dummy message so idle handler processing will
1232     // start up again.  Doing it this way ensures that the idle handler
1233     // wakes up in the right thread (see also wxWakeUpMainThread() which does
1234     // the same for the main app thread only)
1235     //
1236     wxWindow*                       pTopWindow = wxTheApp->GetTopWindow();
1237
1238     if (pTopWindow)
1239     {
1240         if ( !::WinPostMsg(GetHwndOf(pTopWindow), WM_NULL, (MPARAM)0, (MPARAM)0))
1241         {
1242             //
1243             // Should never happen
1244             //
1245             wxLogLastError("PostMessage(WM_NULL)");
1246         }
1247     }
1248 } // end of wxWakeUpIdle
1249
1250 HAB wxGetInstance()
1251 {
1252     return vHabmain;
1253 }
1254
1255 void wxSetInstance(
1256   HAB                               vHab
1257 )
1258 {
1259     vHabmain = vHab;
1260 }
1261