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 #endif
  37
  38 #include "wx/log.h"
  39 #include "wx/module.h"
  40
  41 #include "wx/os2/private.h"
  42
  43 #ifdef __EMX__
  44
  45 #include <sys/ioctl.h>
  46 #include <sys/select.h>
  47
  48 #else
  49
  50 #include <nerrno.h>
  51 #include <sys/ioctl.h>
  52 #include <sys/select.h>
  53 #include <sys/time.h>
  54
  55 #endif //
  56
  57 #ifndef __EMX__
  58
  59 #define select(a,b,c,d,e) bsdselect(a,b,c,d,e)
  60 extern "C" int _System bsdselect(int,
  61                                  struct fd_set *,
  62                                  struct fd_set *,
  63                                  struct fd_set *,
  64                                  struct timeval *);
  65 #endif
  66
  67 #if wxUSE_THREADS
  68     #include "wx/thread.h"
  69 #endif // wxUSE_THREADS
  70
  71 #if wxUSE_TOOLTIPS
  72     #include "wx/tooltip.h"
  73 #endif // wxUSE_TOOLTIPS
  74
  75 #include <string.h>
  76 #include <ctype.h>
  77
  78 // ---------------------------------------------------------------------------
  79 // global variables
  80 // ---------------------------------------------------------------------------
  81
  82 extern wxChar*                      wxBuffer;
  83 extern wxList*                      wxWinHandleList;
  84 extern wxList WXDLLEXPORT           wxPendingDelete;
  85 extern wxCursor*                    g_globalCursor;
  86
  87 HAB                                 vHabmain = NULLHANDLE;
  88
  89
  90 HICON wxSTD_FRAME_ICON          = (HICON) NULL;
  91 HICON wxSTD_MDICHILDFRAME_ICON  = (HICON) NULL;
  92 HICON wxSTD_MDIPARENTFRAME_ICON = (HICON) NULL;
  93
  94 HICON wxDEFAULT_FRAME_ICON           = (HICON) NULL;
  95 HICON wxDEFAULT_MDICHILDFRAME_ICON   = (HICON) NULL;
  96 HICON wxDEFAULT_MDIPARENTFRAME_ICON  = (HICON) NULL;
  97
  98 HBRUSH wxDisableButtonBrush = (HBRUSH) 0;
  99
 100 MRESULT EXPENTRY wxWndProc( HWND hWnd,ULONG message,MPARAM mp1,MPARAM mp2);
 101 MRESULT EXPENTRY wxFrameWndProc( HWND hWnd,ULONG message,MPARAM mp1,MPARAM mp2);
 102
 103 // ===========================================================================
 104 // implementation
 105 // ===========================================================================
 106
 107 // ---------------------------------------------------------------------------
 108 // helper struct and functions for socket handling
 109 // ---------------------------------------------------------------------------
 110
 111 struct GsocketCallbackInfo{
 112     void (*proc)(void *);
 113     int type;
 114     int handle;
 115     void* gsock;
 116 };
 117
 118 // These defines are used here and in gsockpm.cpp
 119 #define wxSockReadMask  0x01
 120 #define wxSockWriteMask 0x02
 121
 122 void wxApp::HandleSockets()
 123 {
 124     bool pendingEvent = FALSE;
 125
 126     // Check whether it's time for Gsocket operation
 127     if (m_maxSocketHandles > 0 && m_maxSocketNr > 0)
 128     {
 129         fd_set readfds = m_readfds;
 130         fd_set writefds = m_writefds;
 131         struct timeval timeout;
 132         int i;
 133         struct GsocketCallbackInfo
 134           *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
 135         timeout.tv_sec = 0;
 136         timeout.tv_usec = 0;
 137         if ( select(m_maxSocketNr, &readfds, &writefds, 0, &timeout) > 0)
 138         {
 139             for (i = m_lastUsedHandle + 1; i != m_lastUsedHandle;
 140                  (i < m_maxSocketNr - 1) ? i++ : (i = 0))
 141             {
 142                 if (FD_ISSET(i, &readfds))
 143                 {
 144                     int r;
 145                     for (r = 0; r < m_maxSocketHandles; r++){
 146                         if(CallbackInfo[r].handle == i &&
 147                            CallbackInfo[r].type == wxSockReadMask)
 148                             break;
 149                     }
 150                     if (r < m_maxSocketHandles)
 151                     {
 152                         CallbackInfo[r].proc(CallbackInfo[r].gsock);
 153                         pendingEvent = TRUE;
 154                     }
 155                 }
 156                 if (FD_ISSET(i, &writefds))
 157                 {
 158                     int r;
 159                     for (r = 0; r < m_maxSocketHandles; r++)
 160                         if(CallbackInfo[r].handle == i &&
 161                            CallbackInfo[r].type == wxSockWriteMask)
 162                             break;
 163                     if (r < m_maxSocketHandles)
 164                     {
 165                         CallbackInfo[r].proc(CallbackInfo[r].gsock);
 166                         pendingEvent = TRUE;
 167                     }
 168                 }
 169             }
 170             m_lastUsedHandle = i;
 171         }
 172         if (pendingEvent)
 173             ProcessPendingEvents();
 174     }
 175 }
 176 // ---------------------------------------------------------------------------
 177 // wxApp
 178 // ---------------------------------------------------------------------------
 179
 180     IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
 181
 182     BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
 183         EVT_IDLE(wxApp::OnIdle)
 184         EVT_END_SESSION(wxApp::OnEndSession)
 185         EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession)
 186     END_EVENT_TABLE()
 187
 188 //
 189 // Initialize
 190 //
 191 bool wxApp::Initialize(int& argc, wxChar **argv)
 192 {
 193     if ( !wxAppBase::Initialize(argc, argv) )
 194         return false;
 195
 196 #if defined(wxUSE_CONSOLEDEBUG)
 197   #if wxUSE_CONSOLEDEBUG
 198 /***********************************************/
 199 /* Code for using stdout debug                 */
 200 /* To use it you mast link app as "Window" - EK*/
 201 /***********************************************/
 202   {
 203      PPIB pib;
 204      PTIB tib;
 205
 206     printf("In console\n");
 207
 208   DosGetInfoBlocks(&tib, &pib);
 209 /* Try morphing into a PM application. */
 210 //  if(pib->pib_ultype == 2)    /* VIO */
 211     pib->pib_ultype = 3;
 212    }
 213 /**********************************************/
 214 /**********************************************/
 215   #endif //wxUSE_CONSOLEDEBUG
 216 #endif
 217
 218     //
 219     // OS2 has to have an anchorblock
 220     //
 221     vHabmain = WinInitialize(0);
 222
 223     if (!vHabmain)
 224     {
 225         // TODO: at least give some error message here...
 226         wxAppBase::CleanUp();
 227
 228         return FALSE;
 229     }
 230
 231     wxBuffer = new wxChar[1500]; // FIXME; why?
 232
 233     // Some people may wish to use this, but
 234     // probably it shouldn't be here by default.
 235 #ifdef __WXDEBUG__
 236     //    wxRedirectIOToConsole();
 237 #endif
 238
 239     wxWinHandleList = new wxList(wxKEY_INTEGER);
 240
 241     // This is to foil optimizations in Visual C++ that throw out dummy.obj.
 242     // PLEASE DO NOT ALTER THIS.
 243 #if !defined(WXMAKINGDLL) && defined(__VISAGECPP__)
 244     extern char wxDummyChar;
 245     if (wxDummyChar) wxDummyChar++;
 246 #endif
 247
 248     // wxSetKeyboardHook(TRUE);
 249
 250     RegisterWindowClasses(vHabmain);
 251
 252     return TRUE;
 253 } // end of wxApp::Initialize
 254
 255 const char*                         CANTREGISTERCLASS = " Can't register Class ";
 256 // ---------------------------------------------------------------------------
 257 // RegisterWindowClasses
 258 // ---------------------------------------------------------------------------
 259
 260 bool wxApp::RegisterWindowClasses(
 261   HAB                               vHab
 262 )
 263 {
 264     ERRORID                         vError = 0L;
 265     wxString                        sError;
 266
 267     if (!::WinRegisterClass( vHab
 268                             ,wxFrameClassName
 269                             ,wxFrameWndProc
 270                             ,CS_SIZEREDRAW | CS_SYNCPAINT
 271                             ,sizeof(ULONG)
 272                            ))
 273     {
 274         vError = ::WinGetLastError(vHab);
 275         sError = wxPMErrorToStr(vError);
 276         wxLogLastError(sError.c_str());
 277         return FALSE;
 278     }
 279
 280     if (!::WinRegisterClass( vHab
 281                             ,wxFrameClassNameNoRedraw
 282                             ,wxWndProc
 283                             ,0
 284                             ,sizeof(ULONG)
 285                            ))
 286     {
 287         vError = ::WinGetLastError(vHab);
 288         sError = wxPMErrorToStr(vError);
 289         wxLogLastError(sError.c_str());
 290         return FALSE;
 291     }
 292
 293     if (!::WinRegisterClass( vHab
 294                             ,wxMDIFrameClassName
 295                             ,wxWndProc
 296                             ,CS_SIZEREDRAW | CS_MOVENOTIFY | CS_SYNCPAINT
 297                             ,sizeof(ULONG)
 298                            ))
 299     {
 300         vError = ::WinGetLastError(vHab);
 301         sError = wxPMErrorToStr(vError);
 302         wxLogLastError(sError.c_str());
 303         return FALSE;
 304     }
 305
 306     if (!::WinRegisterClass( vHab
 307                             ,wxMDIFrameClassNameNoRedraw
 308                             ,wxWndProc
 309                             ,0
 310                             ,sizeof(ULONG)
 311                            ))
 312     {
 313         vError = ::WinGetLastError(vHab);
 314         sError = wxPMErrorToStr(vError);
 315         wxLogLastError(sError.c_str());
 316         return FALSE;
 317     }
 318
 319     if (!::WinRegisterClass( vHab
 320                             ,wxMDIChildFrameClassName
 321                             ,wxWndProc
 322                             ,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_SYNCPAINT | CS_HITTEST
 323                             ,sizeof(ULONG)
 324                            ))
 325     {
 326         vError = ::WinGetLastError(vHab);
 327         sError = wxPMErrorToStr(vError);
 328         wxLogLastError(sError.c_str());
 329         return FALSE;
 330     }
 331
 332     if (!::WinRegisterClass( vHab
 333                             ,wxMDIChildFrameClassNameNoRedraw
 334                             ,wxWndProc
 335                             ,CS_HITTEST
 336                             ,sizeof(ULONG)
 337                            ))
 338     {
 339         vError = ::WinGetLastError(vHab);
 340         sError = wxPMErrorToStr(vError);
 341         wxLogLastError(sError.c_str());
 342         return FALSE;
 343     }
 344
 345     if (!::WinRegisterClass( vHab
 346                             ,wxPanelClassName
 347                             ,wxWndProc
 348                             ,CS_MOVENOTIFY | CS_SIZEREDRAW | CS_HITTEST | CS_SAVEBITS | CS_SYNCPAINT
 349                             ,sizeof(ULONG)
 350                            ))
 351     {
 352         vError = ::WinGetLastError(vHab);
 353         sError = wxPMErrorToStr(vError);
 354         wxLogLastError(sError.c_str());
 355         return FALSE;
 356     }
 357
 358     if (!::WinRegisterClass( vHab
 359                             ,wxCanvasClassName
 360                             ,wxWndProc
 361                             ,CS_SIZEREDRAW | CS_HITTEST | CS_SYNCPAINT
 362                             ,sizeof(ULONG)
 363                            ))
 364     {
 365         vError = ::WinGetLastError(vHab);
 366         sError = wxPMErrorToStr(vError);
 367         wxLogLastError(sError.c_str());
 368         return FALSE;
 369     }
 370     if (!::WinRegisterClass( vHab
 371                             ,wxCanvasClassNameNR
 372                             ,wxWndProc
 373                             ,CS_HITTEST | CS_SYNCPAINT
 374                             ,sizeof(ULONG)
 375                            ))
 376     {
 377         vError = ::WinGetLastError(vHab);
 378         sError = wxPMErrorToStr(vError);
 379         wxLogLastError(sError.c_str());
 380         return FALSE;
 381     }
 382     return TRUE;
 383 } // end of wxApp::RegisterWindowClasses
 384
 385 //
 386 // Cleans up any wxWidgets internal structures left lying around
 387 //
 388 void wxApp::CleanUp()
 389 {
 390     delete[] wxBuffer;
 391     wxBuffer = NULL;
 392
 393     //
 394     // PM-SPECIFIC CLEANUP
 395     //
 396
 397     // wxSetKeyboardHook(FALSE);
 398
 399     if (wxSTD_FRAME_ICON)
 400         ::WinFreeFileIcon(wxSTD_FRAME_ICON);
 401     if (wxSTD_MDICHILDFRAME_ICON)
 402         ::WinFreeFileIcon(wxSTD_MDICHILDFRAME_ICON);
 403     if (wxSTD_MDIPARENTFRAME_ICON)
 404         ::WinFreeFileIcon(wxSTD_MDIPARENTFRAME_ICON);
 405
 406     if (wxDEFAULT_FRAME_ICON)
 407         ::WinFreeFileIcon(wxDEFAULT_FRAME_ICON);
 408     if (wxDEFAULT_MDICHILDFRAME_ICON)
 409         ::WinFreeFileIcon(wxDEFAULT_MDICHILDFRAME_ICON);
 410     if (wxDEFAULT_MDIPARENTFRAME_ICON)
 411         ::WinFreeFileIcon(wxDEFAULT_MDIPARENTFRAME_ICON);
 412
 413     if ( wxDisableButtonBrush )
 414     {
 415 // TODO:        ::DeleteObject( wxDisableButtonBrush );
 416     }
 417
 418     if (wxWinHandleList)
 419         delete wxWinHandleList;
 420
 421     // Delete Message queue
 422     if (wxTheApp->m_hMq)
 423         ::WinDestroyMsgQueue(wxTheApp->m_hMq);
 424
 425     wxAppBase::CleanUp();
 426 } // end of wxApp::CleanUp
 427
 428 bool wxApp::OnInitGui()
 429 {
 430     ERRORID                         vError;
 431     wxString                        sError;
 432
 433     if (!wxAppBase::OnInitGui())
 434         return FALSE;
 435
 436     m_hMq = ::WinCreateMsgQueue(vHabmain, 0);
 437     if (!m_hMq)
 438     {
 439         vError = ::WinGetLastError(vHabmain);
 440         sError = wxPMErrorToStr(vError);
 441         wxLogDebug(sError);
 442         return FALSE;
 443     }
 444
 445     return TRUE;
 446 } // end of wxApp::OnInitGui
 447
 448 wxApp::wxApp()
 449 {
 450     argc = 0;
 451     argv = NULL;
 452     m_nPrintMode = wxPRINT_WINDOWS;
 453     m_hMq = 0;
 454     m_maxSocketHandles = 0;
 455     m_maxSocketNr = 0;
 456     m_sockCallbackInfo = 0;
 457 } // end of wxApp::wxApp
 458
 459 wxApp::~wxApp()
 460 {
 461     //
 462     // Delete command-line args
 463     //
 464 #if wxUSE_UNICODE
 465     int                             i;
 466
 467     for (i = 0; i < argc; i++)
 468     {
 469         delete[] argv[i];
 470     }
 471     delete[] argv;
 472 #endif
 473 } // end of wxApp::~wxApp
 474
 475 bool                                gbInOnIdle = FALSE;
 476
 477 void wxApp::OnIdle(
 478   wxIdleEvent&                      rEvent
 479 )
 480 {
 481
 482     //
 483     // Avoid recursion (via ProcessEvent default case)
 484     //
 485     if (gbInOnIdle)
 486         return;
 487
 488     gbInOnIdle = TRUE;
 489
 490     wxAppBase::OnIdle(rEvent);
 491
 492 #if wxUSE_DC_CACHEING
 493     // automated DC cache management: clear the cached DCs and bitmap
 494     // if it's likely that the app has finished with them, that is, we
 495     // get an idle event and we're not dragging anything.
 496     if (!::WinGetKeyState(HWND_DESKTOP, VK_BUTTON1) &&
 497         !::WinGetKeyState(HWND_DESKTOP, VK_BUTTON3) &&
 498         !::WinGetKeyState(HWND_DESKTOP, VK_BUTTON2))
 499         wxDC::ClearCache();
 500 #endif // wxUSE_DC_CACHEING
 501
 502     gbInOnIdle = FALSE;
 503 } // end of wxApp::OnIdle
 504
 505 void wxApp::OnEndSession(
 506   wxCloseEvent&                     WXUNUSED(rEvent))
 507 {
 508     if (GetTopWindow())
 509         GetTopWindow()->Close(TRUE);
 510 } // end of wxApp::OnEndSession
 511
 512 //
 513 // Default behaviour: close the application with prompts. The
 514 // user can veto the close, and therefore the end session.
 515 //
 516 void wxApp::OnQueryEndSession(
 517   wxCloseEvent&                     rEvent
 518 )
 519 {
 520     if (GetTopWindow())
 521     {
 522         if (!GetTopWindow()->Close(!rEvent.CanVeto()))
 523             rEvent.Veto(TRUE);
 524     }
 525 } // end of wxApp::OnQueryEndSession
 526
 527 //
 528 // Yield to incoming messages
 529 //
 530 bool wxApp::Yield(bool onlyIfNeeded)
 531 {
 532     static bool s_inYield = FALSE;
 533
 534     if ( s_inYield )
 535     {
 536         if ( !onlyIfNeeded )
 537         {
 538             wxFAIL_MSG( _T("wxYield() called recursively") );
 539         }
 540
 541         return FALSE;
 542     }
 543
 544     HAB                             vHab = 0;
 545     QMSG                            vMsg;
 546
 547     //
 548     // Disable log flushing from here because a call to wxYield() shouldn't
 549     // normally result in message boxes popping up &c
 550     //
 551     wxLog::Suspend();
 552
 553     s_inYield = TRUE;
 554
 555     //
 556     // We want to go back to the main message loop
 557     // if we see a WM_QUIT. (?)
 558     //
 559     while (::WinPeekMsg(vHab, &vMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) && vMsg.msg != WM_QUIT)
 560     {
 561 #if wxUSE_THREADS
 562         wxMutexGuiLeaveOrEnter();
 563 #endif // wxUSE_THREADS
 564         if (!wxTheApp->Dispatch())
 565             break;
 566     }
 567     //
 568     // If they are pending events, we must process them.
 569     //
 570     if (wxTheApp)
 571         wxTheApp->ProcessPendingEvents();
 572
 573     HandleSockets();
 574     //
 575     // Let the logs be flashed again
 576     //
 577     wxLog::Resume();
 578     s_inYield = FALSE;
 579     return TRUE;
 580 } // end of wxYield
 581
 582 int wxApp::AddSocketHandler(int handle, int mask,
 583                             void (*callback)(void*), void * gsock)
 584 {
 585     int find;
 586     struct GsocketCallbackInfo
 587         *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
 588
 589     for (find = 0; find < m_maxSocketHandles; find++)
 590         if (CallbackInfo[find].handle == -1)
 591             break;
 592     if (find == m_maxSocketHandles)
 593     {
 594         // Allocate new memory
 595         m_sockCallbackInfo = realloc(m_sockCallbackInfo,
 596                                      (m_maxSocketHandles+=10)*
 597                                      sizeof(struct GsocketCallbackInfo));
 598         CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
 599         for (find = m_maxSocketHandles - 10; find < m_maxSocketHandles; find++)
 600             CallbackInfo[find].handle = -1;
 601         find = m_maxSocketHandles - 10;
 602     }
 603     CallbackInfo[find].proc = callback;
 604     CallbackInfo[find].type = mask;
 605     CallbackInfo[find].handle = handle;
 606     CallbackInfo[find].gsock = gsock;
 607     if (mask & wxSockReadMask)
 608         FD_SET(handle, &m_readfds);
 609     if (mask & wxSockWriteMask)
 610         FD_SET(handle, &m_writefds);
 611     if (handle >= m_maxSocketNr)
 612         m_maxSocketNr = handle + 1;
 613     return find;
 614 }
 615
 616 void wxApp::RemoveSocketHandler(int handle)
 617 {
 618     struct GsocketCallbackInfo
 619         *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
 620     if (handle < m_maxSocketHandles)
 621     {
 622         if (CallbackInfo[handle].type & wxSockReadMask)
 623             FD_CLR(CallbackInfo[handle].handle, &m_readfds);
 624         if (CallbackInfo[handle].type & wxSockWriteMask)
 625             FD_CLR(CallbackInfo[handle].handle, &m_writefds);
 626         CallbackInfo[handle].handle = -1;
 627     }
 628 }
 629
 630 //-----------------------------------------------------------------------------
 631 // wxWakeUpIdle
 632 //-----------------------------------------------------------------------------
 633
 634 void wxApp::WakeUpIdle()
 635 {
 636     //
 637     // Send the top window a dummy message so idle handler processing will
 638     // start up again.  Doing it this way ensures that the idle handler
 639     // wakes up in the right thread (see also wxWakeUpMainThread() which does
 640     // the same for the main app thread only)
 641     //
 642     wxWindow*                       pTopWindow = wxTheApp->GetTopWindow();
 643
 644     if (pTopWindow)
 645     {
 646         if ( !::WinPostMsg(GetHwndOf(pTopWindow), WM_NULL, (MPARAM)0, (MPARAM)0))
 647         {
 648             //
 649             // Should never happen
 650             //
 651             wxLogLastError("PostMessage(WM_NULL)");
 652         }
 653     }
 654 } // end of wxWakeUpIdle
 655
 656 HAB wxGetInstance()
 657 {
 658     return vHabmain;
 659 }
 660
 661 void wxSetInstance(
 662   HAB                               vHab
 663 )
 664 {
 665     vHabmain = vHab;
 666 }
 667