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