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