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