Commit | Line | Data |
---|---|---|
251b80c4 | 1 | /////////////////////////////////////////////////////////////////////////////// |
e4db172a | 2 | // Name: src/os2/evtloop.cpp |
b46b1d59 | 3 | // Purpose: implements wxGUIEventLoop for PM |
251b80c4 KB |
4 | // Author: Vadim Zeitlin |
5 | // Modified by: | |
6 | // Created: 01.06.01 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr> | |
526954c5 | 9 | // Licence: wxWindows licence |
251b80c4 KB |
10 | /////////////////////////////////////////////////////////////////////////////// |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
251b80c4 KB |
20 | // For compilers that support precompilation, includes "wx.h". |
21 | #include "wx/wxprec.h" | |
22 | ||
23 | #ifdef __BORLANDC__ | |
24 | #pragma hdrstop | |
25 | #endif | |
26 | ||
27 | #ifndef WX_PRECOMP | |
28 | #include "wx/window.h" | |
29 | #include "wx/app.h" | |
598dc9b7 | 30 | #include "wx/timer.h" |
e4db172a | 31 | #include "wx/log.h" |
251b80c4 KB |
32 | #endif //WX_PRECOMP |
33 | ||
34 | #include "wx/evtloop.h" | |
35 | #include "wx/tooltip.h" | |
664e1314 | 36 | #include "wx/scopedptr.h" |
251b80c4 KB |
37 | |
38 | #include "wx/os2/private.h" | |
55bfbcb9 | 39 | #include "wx/os2/private/timer.h" // for wxTimerProc |
251b80c4 KB |
40 | |
41 | #if wxUSE_THREADS | |
42 | // define the array of QMSG strutures | |
43 | WX_DECLARE_OBJARRAY(QMSG, wxMsgArray); | |
598dc9b7 SN |
44 | |
45 | #include "wx/arrimpl.cpp" | |
46 | ||
47 | WX_DEFINE_OBJARRAY(wxMsgArray); | |
251b80c4 KB |
48 | #endif |
49 | ||
598dc9b7 | 50 | extern HAB vHabmain; |
251b80c4 KB |
51 | |
52 | // ---------------------------------------------------------------------------- | |
53 | // wxEventLoopImpl | |
54 | // ---------------------------------------------------------------------------- | |
55 | ||
56 | class WXDLLEXPORT wxEventLoopImpl | |
57 | { | |
58 | public: | |
59 | // ctor | |
60 | wxEventLoopImpl() { SetExitCode(0); } | |
61 | ||
62 | // process a message | |
63 | void ProcessMessage(QMSG *msg); | |
64 | ||
65 | // generate an idle message, return TRUE if more idle time requested | |
66 | bool SendIdleMessage(); | |
67 | ||
68 | // set/get the exit code | |
69 | void SetExitCode(int exitcode) { m_exitcode = exitcode; } | |
70 | int GetExitCode() const { return m_exitcode; } | |
71 | ||
72 | private: | |
73 | // preprocess a message, return TRUE if processed (i.e. no further | |
74 | // dispatching required) | |
75 | bool PreProcessMessage(QMSG *msg); | |
76 | ||
77 | // the exit code of the event loop | |
78 | int m_exitcode; | |
79 | }; | |
80 | ||
598dc9b7 SN |
81 | // ---------------------------------------------------------------------------- |
82 | // helper class | |
83 | // ---------------------------------------------------------------------------- | |
84 | ||
85 | wxDEFINE_TIED_SCOPED_PTR_TYPE(wxEventLoopImpl); | |
86 | ||
251b80c4 KB |
87 | // ============================================================================ |
88 | // wxEventLoopImpl implementation | |
89 | // ============================================================================ | |
90 | ||
91 | // ---------------------------------------------------------------------------- | |
92 | // wxEventLoopImpl message processing | |
93 | // ---------------------------------------------------------------------------- | |
94 | ||
95 | void wxEventLoopImpl::ProcessMessage(QMSG *msg) | |
96 | { | |
97 | // give us the chance to preprocess the message first | |
98 | if ( !PreProcessMessage(msg) ) | |
99 | { | |
100 | // if it wasn't done, dispatch it to the corresponding window | |
598dc9b7 | 101 | ::WinDispatchMsg(vHabmain, msg); |
251b80c4 KB |
102 | } |
103 | } | |
104 | ||
598dc9b7 | 105 | bool wxEventLoopImpl::PreProcessMessage(QMSG *pMsg) |
251b80c4 | 106 | { |
598dc9b7 SN |
107 | HWND hWnd = pMsg->hwnd; |
108 | wxWindow *pWndThis = wxFindWinFromHandle((WXHWND)hWnd); | |
109 | wxWindow *pWnd; | |
110 | ||
111 | // | |
112 | // Pass non-system timer messages to the wxTimerProc | |
113 | // | |
114 | if (pMsg->msg == WM_TIMER && | |
115 | (SHORT1FROMMP(pMsg->mp1) != TID_CURSOR && | |
116 | SHORT1FROMMP(pMsg->mp1) != TID_FLASHWINDOW && | |
117 | SHORT1FROMMP(pMsg->mp1) != TID_SCROLL && | |
118 | SHORT1FROMMP(pMsg->mp1) != 0x0000 | |
119 | )) | |
120 | wxTimerProc(NULL, 0, (int)pMsg->mp1, 0); | |
121 | ||
122 | // Allow the window to prevent certain messages from being | |
123 | // translated/processed (this is currently used by wxTextCtrl to always | |
124 | // grab Ctrl-C/V/X, even if they are also accelerators in some parent) | |
125 | // | |
126 | if (pWndThis && !pWndThis->OS2ShouldPreProcessMessage((WXMSG*)pMsg)) | |
251b80c4 | 127 | { |
598dc9b7 | 128 | return FALSE; |
251b80c4 | 129 | } |
251b80c4 | 130 | |
598dc9b7 SN |
131 | // |
132 | // For some composite controls (like a combobox), wndThis might be NULL | |
133 | // because the subcontrol is not a wxWindow, but only the control itself | |
134 | // is - try to catch this case | |
135 | // | |
136 | while (hWnd && !pWndThis) | |
251b80c4 | 137 | { |
598dc9b7 SN |
138 | hWnd = ::WinQueryWindow(hWnd, QW_PARENT); |
139 | pWndThis = wxFindWinFromHandle((WXHWND)hWnd); | |
251b80c4 KB |
140 | } |
141 | ||
598dc9b7 SN |
142 | |
143 | // | |
144 | // Try translations first; find the youngest window with | |
145 | // a translation table. OS/2 has case sensiive accels, so | |
146 | // this block, coded by BK, removes that and helps make them | |
147 | // case insensitive. | |
148 | // | |
149 | if(pMsg->msg == WM_CHAR) | |
251b80c4 | 150 | { |
598dc9b7 SN |
151 | PBYTE pChmsg = (PBYTE)&(pMsg->msg); |
152 | USHORT uSch = CHARMSG(pChmsg)->chr; | |
153 | bool bRc = FALSE; | |
154 | ||
155 | // | |
156 | // Do not process keyup events | |
157 | // | |
158 | if(!(CHARMSG(pChmsg)->fs & KC_KEYUP)) | |
159 | { | |
160 | if((CHARMSG(pChmsg)->fs & (KC_ALT | KC_CTRL)) && CHARMSG(pChmsg)->chr != 0) | |
161 | CHARMSG(pChmsg)->chr = (USHORT)wxToupper((UCHAR)uSch); | |
162 | ||
163 | ||
164 | for(pWnd = pWndThis; pWnd; pWnd = pWnd->GetParent() ) | |
165 | { | |
166 | if((bRc = pWnd->OS2TranslateMessage((WXMSG*)pMsg)) == TRUE) | |
e7d70ef0 | 167 | break; |
e4db172a WS |
168 | // stop at first top level window, i.e. don't try to process the |
169 | // key strokes originating in a dialog using the accelerators of | |
170 | // the parent frame - this doesn't make much sense | |
171 | if ( pWnd->IsTopLevel() ) | |
172 | break; | |
598dc9b7 SN |
173 | } |
174 | ||
175 | if(!bRc) // untranslated, should restore original value | |
176 | CHARMSG(pChmsg)->chr = uSch; | |
177 | } | |
251b80c4 | 178 | } |
598dc9b7 SN |
179 | // |
180 | // Anyone for a non-translation message? Try youngest descendants first. | |
181 | // | |
182 | // for (pWnd = pWndThis->GetParent(); pWnd; pWnd = pWnd->GetParent()) | |
183 | // { | |
184 | // if (pWnd->OS2ProcessMessage(pWxmsg)) | |
185 | // return TRUE; | |
186 | // } | |
251b80c4 KB |
187 | return FALSE; |
188 | } | |
189 | ||
190 | // ---------------------------------------------------------------------------- | |
191 | // wxEventLoopImpl idle event processing | |
192 | // ---------------------------------------------------------------------------- | |
193 | ||
194 | bool wxEventLoopImpl::SendIdleMessage() | |
195 | { | |
e39af974 | 196 | return wxTheApp->ProcessIdle() ; |
251b80c4 KB |
197 | } |
198 | ||
199 | // ============================================================================ | |
b46b1d59 | 200 | // wxGUIEventLoop implementation |
251b80c4 KB |
201 | // ============================================================================ |
202 | ||
251b80c4 | 203 | // ---------------------------------------------------------------------------- |
b46b1d59 | 204 | // wxGUIEventLoop running and exiting |
251b80c4 KB |
205 | // ---------------------------------------------------------------------------- |
206 | ||
b46b1d59 | 207 | wxGUIEventLoop::~wxGUIEventLoop() |
251b80c4 | 208 | { |
9a83f860 | 209 | wxASSERT_MSG( !m_impl, wxT("should have been deleted in Run()") ); |
251b80c4 KB |
210 | } |
211 | ||
598dc9b7 SN |
212 | ////////////////////////////////////////////////////////////////////////////// |
213 | // | |
214 | // Keep trying to process messages until WM_QUIT | |
215 | // received. | |
216 | // | |
217 | // If there are messages to be processed, they will all be | |
218 | // processed and OnIdle will not be called. | |
219 | // When there are no more messages, OnIdle is called. | |
220 | // If OnIdle requests more time, | |
221 | // it will be repeatedly called so long as there are no pending messages. | |
222 | // A 'feature' of this is that once OnIdle has decided that no more processing | |
223 | // is required, then it won't get processing time until further messages | |
224 | // are processed (it'll sit in Dispatch). | |
225 | // | |
226 | ////////////////////////////////////////////////////////////////////////////// | |
227 | class CallEventLoopMethod | |
228 | { | |
229 | public: | |
b46b1d59 | 230 | typedef void (wxGUIEventLoop::*FuncType)(); |
598dc9b7 | 231 | |
b46b1d59 | 232 | CallEventLoopMethod(wxGUIEventLoop *evtLoop, FuncType fn) |
598dc9b7 SN |
233 | : m_evtLoop(evtLoop), m_fn(fn) { } |
234 | ~CallEventLoopMethod() { (m_evtLoop->*m_fn)(); } | |
235 | ||
236 | private: | |
b46b1d59 | 237 | wxGUIEventLoop *m_evtLoop; |
598dc9b7 SN |
238 | FuncType m_fn; |
239 | }; | |
240 | ||
b46b1d59 | 241 | int wxGUIEventLoop::Run() |
251b80c4 KB |
242 | { |
243 | // event loops are not recursive, you need to create another loop! | |
9a83f860 | 244 | wxCHECK_MSG( !IsRunning(), -1, wxT("can't reenter a message loop") ); |
251b80c4 | 245 | |
598dc9b7 SN |
246 | // SendIdleMessage() and Dispatch() below may throw so the code here should |
247 | // be exception-safe, hence we must use local objects for all actions we | |
248 | // should undo | |
77fb1a02 | 249 | wxEventLoopActivator activate(this); |
598dc9b7 | 250 | wxEventLoopImplTiedPtr impl(&m_impl, new wxEventLoopImpl); |
251b80c4 | 251 | |
b46b1d59 | 252 | CallEventLoopMethod callOnExit(this, &wxGUIEventLoop::OnExit); |
251b80c4 KB |
253 | |
254 | for ( ;; ) | |
255 | { | |
256 | #if wxUSE_THREADS | |
257 | wxMutexGuiLeaveOrEnter(); | |
258 | #endif // wxUSE_THREADS | |
259 | ||
260 | // generate and process idle events for as long as we don't have | |
261 | // anything else to do | |
262 | while ( !Pending() && m_impl->SendIdleMessage() ) | |
e4db172a WS |
263 | { |
264 | wxTheApp->HandleSockets(); | |
265 | wxMilliSleep(10); | |
266 | } | |
598dc9b7 SN |
267 | |
268 | wxTheApp->HandleSockets(); | |
269 | if (Pending()) | |
e4db172a WS |
270 | { |
271 | if ( !Dispatch() ) | |
272 | { | |
273 | // we got WM_QUIT | |
274 | break; | |
275 | } | |
276 | } | |
598dc9b7 | 277 | else |
d3a919bd | 278 | wxMilliSleep(10); |
251b80c4 KB |
279 | } |
280 | ||
16d17da6 VZ |
281 | OnExit(); |
282 | ||
598dc9b7 | 283 | return m_impl->GetExitCode(); |
251b80c4 KB |
284 | } |
285 | ||
b46b1d59 | 286 | void wxGUIEventLoop::Exit(int rc) |
251b80c4 | 287 | { |
9a83f860 | 288 | wxCHECK_RET( IsRunning(), wxT("can't call Exit() if not running") ); |
251b80c4 KB |
289 | |
290 | m_impl->SetExitCode(rc); | |
291 | ||
292 | ::WinPostMsg(NULL, WM_QUIT, 0, 0); | |
293 | } | |
294 | ||
295 | // ---------------------------------------------------------------------------- | |
b46b1d59 | 296 | // wxGUIEventLoop message processing dispatching |
251b80c4 KB |
297 | // ---------------------------------------------------------------------------- |
298 | ||
b46b1d59 | 299 | bool wxGUIEventLoop::Pending() const |
251b80c4 KB |
300 | { |
301 | QMSG msg; | |
598dc9b7 | 302 | return ::WinPeekMsg(vHabmain, &msg, 0, 0, 0, PM_NOREMOVE) != 0; |
251b80c4 KB |
303 | } |
304 | ||
b46b1d59 | 305 | bool wxGUIEventLoop::Dispatch() |
251b80c4 | 306 | { |
9a83f860 | 307 | wxCHECK_MSG( IsRunning(), false, wxT("can't call Dispatch() if not running") ); |
251b80c4 KB |
308 | |
309 | QMSG msg; | |
598dc9b7 | 310 | BOOL bRc = ::WinGetMsg(vHabmain, &msg, (HWND) NULL, 0, 0); |
251b80c4 | 311 | |
598dc9b7 | 312 | if ( bRc == 0 ) |
251b80c4 KB |
313 | { |
314 | // got WM_QUIT | |
e4db172a | 315 | return false; |
251b80c4 KB |
316 | } |
317 | ||
251b80c4 KB |
318 | #if wxUSE_THREADS |
319 | wxASSERT_MSG( wxThread::IsMain(), | |
320 | wxT("only the main thread can process Windows messages") ); | |
321 | ||
e4db172a | 322 | static bool s_hadGuiLock = true; |
251b80c4 KB |
323 | static wxMsgArray s_aSavedMessages; |
324 | ||
325 | // if a secondary thread owning the mutex is doing GUI calls, save all | |
326 | // messages for later processing - we can't process them right now because | |
327 | // it will lead to recursive library calls (and we're not reentrant) | |
328 | if ( !wxGuiOwnedByMainThread() ) | |
329 | { | |
e4db172a | 330 | s_hadGuiLock = false; |
251b80c4 KB |
331 | |
332 | // leave out WM_COMMAND messages: too dangerous, sometimes | |
333 | // the message will be processed twice | |
598dc9b7 | 334 | if ( !wxIsWaitingForThread() || msg.msg != WM_COMMAND ) |
251b80c4 KB |
335 | { |
336 | s_aSavedMessages.Add(msg); | |
337 | } | |
338 | ||
e4db172a | 339 | return true; |
251b80c4 KB |
340 | } |
341 | else | |
342 | { | |
343 | // have we just regained the GUI lock? if so, post all of the saved | |
344 | // messages | |
345 | // | |
346 | // FIXME of course, it's not _exactly_ the same as processing the | |
347 | // messages normally - expect some things to break... | |
348 | if ( !s_hadGuiLock ) | |
349 | { | |
e4db172a | 350 | s_hadGuiLock = true; |
251b80c4 KB |
351 | |
352 | size_t count = s_aSavedMessages.Count(); | |
353 | for ( size_t n = 0; n < count; n++ ) | |
354 | { | |
598dc9b7 | 355 | QMSG& msg = s_aSavedMessages[n]; |
251b80c4 KB |
356 | m_impl->ProcessMessage(&msg); |
357 | } | |
358 | ||
359 | s_aSavedMessages.Empty(); | |
360 | } | |
361 | } | |
362 | #endif // wxUSE_THREADS | |
363 | ||
364 | m_impl->ProcessMessage(&msg); | |
365 | ||
e4db172a | 366 | return true; |
251b80c4 | 367 | } |
dde19c21 FM |
368 | |
369 | // | |
370 | // Yield to incoming messages | |
371 | // | |
372 | bool wxGUIEventLoop::YieldFor(long eventsToProcess) | |
373 | { | |
374 | HAB vHab = 0; | |
375 | QMSG vMsg; | |
376 | ||
377 | // | |
378 | // Disable log flushing from here because a call to wxYield() shouldn't | |
379 | // normally result in message boxes popping up &c | |
380 | // | |
381 | wxLog::Suspend(); | |
382 | ||
383 | m_isInsideYield = true; | |
384 | m_eventsToProcessInsideYield = eventsToProcess; | |
385 | ||
386 | // | |
387 | // We want to go back to the main message loop | |
388 | // if we see a WM_QUIT. (?) | |
389 | // | |
390 | while (::WinPeekMsg(vHab, &vMsg, (HWND)NULL, 0, 0, PM_NOREMOVE) && vMsg.msg != WM_QUIT) | |
391 | { | |
392 | // TODO: implement event filtering using the eventsToProcess mask | |
393 | ||
394 | #if wxUSE_THREADS | |
395 | wxMutexGuiLeaveOrEnter(); | |
396 | #endif // wxUSE_THREADS | |
397 | if (!wxTheApp->Dispatch()) | |
398 | break; | |
399 | } | |
400 | ||
401 | // | |
402 | // If they are pending events, we must process them. | |
403 | // | |
404 | if (wxTheApp) | |
e39b5fa4 | 405 | { |
dde19c21 | 406 | wxTheApp->ProcessPendingEvents(); |
03647350 | 407 | wxTheApp->HandleSockets(); |
e39b5fa4 | 408 | } |
dde19c21 FM |
409 | |
410 | // | |
411 | // Let the logs be flashed again | |
412 | // | |
413 | wxLog::Resume(); | |
414 | m_isInsideYield = false; | |
415 | ||
416 | return true; | |
417 | } // end of wxYield |