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         //
 791         // Process the message
 792         //
 793         DoMessage((WXMSG *)&svCurrentMsg);
 794     }
 795     return TRUE;
 796 } // end of wxApp::DoMessage
 797
 798 void wxApp::DoMessage(
 799   WXMSG*                            pMsg
 800 )
 801 {
 802     if (!ProcessMessage((WXMSG *)&svCurrentMsg))
 803     {
 804         ::WinDispatchMsg(vHabmain, (PQMSG)&svCurrentMsg);
 805     }
 806 } // end of wxApp::DoMessage
 807
 808 //////////////////////////////////////////////////////////////////////////////
 809 //
 810 // Keep trying to process messages until WM_QUIT
 811 // received.
 812 //
 813 // If there are messages to be processed, they will all be
 814 // processed and OnIdle will not be called.
 815 // When there are no more messages, OnIdle is called.
 816 // If OnIdle requests more time,
 817 // it will be repeatedly called so long as there are no pending messages.
 818 // A 'feature' of this is that once OnIdle has decided that no more processing
 819 // is required, then it won't get processing time until further messages
 820 // are processed (it'll sit in DoMessage).
 821 //
 822 //////////////////////////////////////////////////////////////////////////////
 823 int wxApp::MainLoop()
 824 {
 825     m_bKeepGoing = TRUE;
 826
 827     while (m_bKeepGoing)
 828     {
 829 #if wxUSE_THREADS
 830         wxMutexGuiLeaveOrEnter();
 831 #endif // wxUSE_THREADS
 832         while (!Pending() && ProcessIdle())
 833         {
 834             HandleSockets();
 835             wxUsleep(10000);
 836         }
 837         HandleSockets();
 838         if (Pending())
 839             DoMessage();
 840         else
 841             wxUsleep(10000);
 842
 843     }
 844     return (int)svCurrentMsg.mp1;
 845 } // end of wxApp::MainLoop
 846
 847 //
 848 // Returns TRUE if more time is needed.
 849 //
 850 bool wxApp::ProcessIdle()
 851 {
 852     wxIdleEvent                     vEvent;
 853
 854     vEvent.SetEventObject(this);
 855     ProcessEvent(vEvent);
 856     return vEvent.MoreRequested();
 857 } // end of wxApp::ProcessIdle
 858
 859 void wxApp::ExitMainLoop()
 860 {
 861     m_bKeepGoing = FALSE;
 862 }
 863
 864 bool wxApp::Pending()
 865 {
 866     return (::WinPeekMsg(vHabmain, (PQMSG)&svCurrentMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) != 0);
 867 }
 868
 869 void wxApp::Dispatch()
 870 {
 871     DoMessage();
 872 }
 873
 874 //////////////////////////////////////////////////////////////////////////////
 875 //
 876 // Give all windows a chance to preprocess
 877 // the message. Some may have accelerator tables, or have
 878 // MDI complications.
 879 //
 880 //////////////////////////////////////////////////////////////////////////////
 881 bool wxApp::ProcessMessage(
 882   WXMSG*                            pWxmsg
 883 )
 884 {
 885     QMSG*                           pMsg = (PQMSG)pWxmsg;
 886     HWND                            hWnd = pMsg->hwnd;
 887     wxWindow*                       pWndThis = wxFindWinFromHandle((WXHWND)hWnd);
 888     wxWindow*                       pWnd;
 889
 890 #if wxUSE_TOOLTIPS
 891     //
 892     // We must relay WM_MOUSEMOVE events to the tooltip ctrl if we want it to
 893     // popup the tooltip bubbles
 894     //
 895     if (pWndThis && (pMsg->msg == WM_MOUSEMOVE))
 896     {
 897         wxToolTip*                  pToolTip = pWndThis->GetToolTip();
 898         if (pToolTip)
 899         {
 900             pToolTip->RelayEvent(pWxmsg);
 901         }
 902     }
 903 #endif // wxUSE_TOOLTIPS
 904
 905     //
 906     // We must relay Timer events to wxTimer's processing function
 907     //
 908     if (pMsg->msg == WM_TIMER)
 909         wxTimerProc(NULL, 0, (int)pMsg->mp1, 0);
 910
 911     //
 912     // For some composite controls (like a combobox), wndThis might be NULL
 913     // because the subcontrol is not a wxWindow, but only the control itself
 914     // is - try to catch this case
 915     //
 916     while (hWnd && !pWndThis)
 917     {
 918         hWnd = ::WinQueryWindow(hWnd, QW_PARENT);
 919         pWndThis = wxFindWinFromHandle((WXHWND)hWnd);
 920     }
 921
 922     //
 923     // Try translations first; find the youngest window with
 924     // a translation table. OS/2 has case sensative accels, so
 925     // this block, coded by BK, removes that and helps make them
 926     // case insensative.
 927     //
 928     if(pMsg->msg == WM_CHAR)
 929     {
 930        PBYTE                        pChmsg = (PBYTE)&(pMsg->msg);
 931        USHORT                       uSch  = CHARMSG(pChmsg)->chr;
 932        bool                         bRc;
 933
 934        //
 935        // Do not process keyup events
 936        //
 937        if(!(CHARMSG(pChmsg)->fs & KC_KEYUP))
 938        {
 939            if((CHARMSG(pChmsg)->fs & (KC_ALT | KC_CTRL)) && CHARMSG(pChmsg)->chr != 0)
 940                 CHARMSG(pChmsg)->chr = (USHORT)wxToupper((UCHAR)uSch);
 941
 942
 943            for(pWnd = pWndThis; pWnd; pWnd = pWnd->GetParent() )
 944            {
 945                if((bRc = pWnd->OS2TranslateMessage(pWxmsg)) == TRUE)
 946                    break;
 947            }
 948
 949             if(!bRc)    // untranslated, should restore original value
 950                 CHARMSG(pChmsg)->chr = uSch;
 951         }
 952     }
 953     //
 954     // Anyone for a non-translation message? Try youngest descendants first.
 955     //
 956 //  for (pWnd = pWndThis; pWnd; pWnd = pWnd->GetParent())
 957 //  {
 958 //      if (pWnd->OS2ProcessMessage(pWxmsg))
 959 //          return TRUE;
 960 //  }
 961     return FALSE;
 962 } // end of wxApp::ProcessMessage
 963
 964 void wxApp::OnIdle(
 965   wxIdleEvent&                      rEvent
 966 )
 967 {
 968     static bool                     sbInOnIdle = FALSE;
 969
 970     //
 971     // Avoid recursion (via ProcessEvent default case)
 972     //
 973     if (sbInOnIdle)
 974         return;
 975
 976     sbInOnIdle = TRUE;
 977
 978     //
 979     // If there are pending events, we must process them: pending events
 980     // are either events to the threads other than main or events posted
 981     // with wxPostEvent() functions
 982     //
 983     ProcessPendingEvents();
 984
 985     //
 986     // 'Garbage' collection of windows deleted with Close().
 987     //
 988     DeletePendingObjects();
 989
 990 #if wxUSE_LOG
 991     //
 992     // Flush the logged messages if any
 993     //
 994     wxLog::FlushActive();
 995 #endif // wxUSE_LOG
 996
 997     //
 998     // Send OnIdle events to all windows
 999     //
1000     if (SendIdleEvents())
1001     {
1002         //
1003         // SendIdleEvents() returns TRUE if at least one window requested more
1004         // idle events
1005         //
1006         rEvent.RequestMore(TRUE);
1007     }
1008     sbInOnIdle = FALSE;
1009 } // end of wxApp::OnIdle
1010
1011 // Send idle event to all top-level windows
1012 bool wxApp::SendIdleEvents()
1013 {
1014     bool                            bNeedMore = FALSE;
1015     wxWindowList::Node*             pNode = wxTopLevelWindows.GetFirst();
1016
1017     while (pNode)
1018     {
1019         wxWindow*                   pWin = pNode->GetData();
1020
1021         if (SendIdleEvents(pWin))
1022             bNeedMore = TRUE;
1023         pNode = pNode->GetNext();
1024     }
1025     return bNeedMore;
1026 } // end of wxApp::SendIdleEvents
1027
1028 //
1029 // Send idle event to window and all subwindows
1030 //
1031 bool wxApp::SendIdleEvents(
1032   wxWindow*                         pWin
1033 )
1034 {
1035     bool                            bNeedMore = FALSE;
1036     wxIdleEvent                     vEvent;
1037
1038     vEvent.SetEventObject(pWin);
1039     pWin->GetEventHandler()->ProcessEvent(vEvent);
1040
1041     if (vEvent.MoreRequested())
1042         bNeedMore = TRUE;
1043
1044     wxNode*                         pNode = pWin->GetChildren().First();
1045
1046     while (pNode)
1047     {
1048         wxWindow*                   pWin = (wxWindow*) pNode->Data();
1049
1050         if (SendIdleEvents(pWin))
1051             bNeedMore = TRUE;
1052         pNode = pNode->Next();
1053     }
1054     return bNeedMore;
1055 } // end of wxApp::SendIdleEvents
1056
1057 void wxApp::DeletePendingObjects()
1058 {
1059     wxNode*                         pNode = wxPendingDelete.First();
1060
1061     while (pNode)
1062     {
1063         wxObject*                   pObj = (wxObject *)pNode->Data();
1064
1065         delete pObj;
1066
1067         if (wxPendingDelete.Member(pObj))
1068             delete pNode;
1069
1070         //
1071         // Deleting one object may have deleted other pending
1072         // objects, so start from beginning of list again.
1073         //
1074         pNode = wxPendingDelete.First();
1075     }
1076 } // end of wxApp::DeletePendingObjects
1077
1078 void wxApp::OnEndSession(
1079   wxCloseEvent&                     WXUNUSED(rEvent))
1080 {
1081     if (GetTopWindow())
1082         GetTopWindow()->Close(TRUE);
1083 } // end of wxApp::OnEndSession
1084
1085 //
1086 // Default behaviour: close the application with prompts. The
1087 // user can veto the close, and therefore the end session.
1088 //
1089 void wxApp::OnQueryEndSession(
1090   wxCloseEvent&                     rEvent
1091 )
1092 {
1093     if (GetTopWindow())
1094     {
1095         if (!GetTopWindow()->Close(!rEvent.CanVeto()))
1096             rEvent.Veto(TRUE);
1097     }
1098 } // end of wxApp::OnQueryEndSession
1099
1100 void wxExit()
1101 {
1102     wxLogError(_("Fatal error: exiting"));
1103
1104     wxApp::CleanUp();
1105 } // end of wxExit
1106
1107 static bool gs_inYield = FALSE;
1108
1109 //
1110 // Yield to incoming messages
1111 //
1112 bool wxYield()
1113 {
1114     HAB                             vHab = 0;
1115     QMSG                            vMsg;
1116
1117     //
1118     // Disable log flushing from here because a call to wxYield() shouldn't
1119     // normally result in message boxes popping up &c
1120     //
1121     wxLog::Suspend();
1122
1123     gs_inYield = TRUE;
1124
1125     //
1126     // We want to go back to the main message loop
1127     // if we see a WM_QUIT. (?)
1128     //
1129     while (::WinPeekMsg(vHab, &vMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) && vMsg.msg != WM_QUIT)
1130     {
1131 #if wxUSE_THREADS
1132         wxMutexGuiLeaveOrEnter();
1133 #endif // wxUSE_THREADS
1134         if (!wxTheApp->DoMessage())
1135             break;
1136     }
1137     //
1138     // If they are pending events, we must process them.
1139     //
1140     if (wxTheApp)
1141         wxTheApp->ProcessPendingEvents();
1142
1143     //
1144     // Let the logs be flashed again
1145     //
1146     wxLog::Resume();
1147     gs_inYield = FALSE;
1148     return TRUE;
1149 } // end of wxYield
1150
1151 // Yield to incoming messages; but fail silently if recursion is detected.
1152 bool wxYieldIfNeeded()
1153 {
1154     if (gs_inYield)
1155         return FALSE;
1156
1157     return wxYield();
1158 }
1159
1160 wxIcon wxApp::GetStdIcon(
1161   int                               nWhich
1162 ) const
1163 {
1164     switch(nWhich)
1165     {
1166         case wxICON_INFORMATION:
1167             return wxIcon("wxICON_INFO");
1168
1169         case wxICON_QUESTION:
1170             return wxIcon("wxICON_QUESTION");
1171
1172         case wxICON_EXCLAMATION:
1173             return wxIcon("wxICON_WARNING");
1174
1175         default:
1176             wxFAIL_MSG(wxT("requested non existent standard icon"));
1177             // still fall through
1178
1179         case wxICON_HAND:
1180             return wxIcon("wxICON_ERROR");
1181     }
1182     return wxIcon("wxICON_ERROR");
1183 } // end of wxApp::GetStdIcon
1184
1185 int wxApp::AddSocketHandler(int handle, int mask,
1186                             void (*callback)(void*), void * gsock)
1187 {
1188     int find;
1189     struct GsocketCallbackInfo
1190         *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
1191
1192     for (find = 0; find < m_maxSocketHandles; find++)
1193         if (CallbackInfo[find].handle == -1)
1194             break;
1195     if (find == m_maxSocketHandles)
1196     {
1197         // Allocate new memory
1198         m_sockCallbackInfo = realloc(m_sockCallbackInfo,
1199                                      (m_maxSocketHandles+=10)*
1200                                      sizeof(struct GsocketCallbackInfo));
1201         CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
1202         for (find = m_maxSocketHandles - 10; find < m_maxSocketHandles; find++)
1203             CallbackInfo[find].handle = -1;
1204         find = m_maxSocketHandles - 10;
1205     }
1206     CallbackInfo[find].proc = callback;
1207     CallbackInfo[find].type = mask;
1208     CallbackInfo[find].handle = handle;
1209     CallbackInfo[find].gsock = gsock;
1210     if (mask & wxSockReadMask)
1211         FD_SET(handle, &m_readfds);
1212     if (mask & wxSockWriteMask)
1213         FD_SET(handle, &m_writefds);
1214     if (handle >= m_maxSocketNr)
1215         m_maxSocketNr = handle + 1;
1216     return find;
1217 }
1218
1219 void wxApp::RemoveSocketHandler(int handle)
1220 {
1221     struct GsocketCallbackInfo
1222         *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
1223     if (handle < m_maxSocketHandles)
1224     {
1225         if (CallbackInfo[handle].type & wxSockReadMask)
1226             FD_CLR(CallbackInfo[handle].handle, &m_readfds);
1227         if (CallbackInfo[handle].type & wxSockWriteMask)
1228             FD_CLR(CallbackInfo[handle].handle, &m_writefds);
1229         CallbackInfo[handle].handle = -1;
1230     }
1231 }
1232
1233 //-----------------------------------------------------------------------------
1234 // wxWakeUpIdle
1235 //-----------------------------------------------------------------------------
1236
1237 void wxWakeUpIdle()
1238 {
1239     //
1240     // Send the top window a dummy message so idle handler processing will
1241     // start up again.  Doing it this way ensures that the idle handler
1242     // wakes up in the right thread (see also wxWakeUpMainThread() which does
1243     // the same for the main app thread only)
1244     //
1245     wxWindow*                       pTopWindow = wxTheApp->GetTopWindow();
1246
1247     if (pTopWindow)
1248     {
1249         if ( !::WinPostMsg(GetHwndOf(pTopWindow), WM_NULL, (MPARAM)0, (MPARAM)0))
1250         {
1251             //
1252             // Should never happen
1253             //
1254             wxLogLastError("PostMessage(WM_NULL)");
1255         }
1256     }
1257 } // end of wxWakeUpIdle
1258
1259 HAB wxGetInstance()
1260 {
1261     return vHabmain;
1262 }
1263
1264 void wxSetInstance(
1265   HAB                               vHab
1266 )
1267 {
1268     vHabmain = vHab;
1269 }
1270