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