]> git.saurik.com Git - wxWidgets.git/blob - src/msw/evtloop.cpp
replaced unweildy GAddress functions with wxSockAddressImpl class, similarly to GSock...
[wxWidgets.git] / src / msw / evtloop.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: msw/evtloop.cpp
3 // Purpose: implements wxEventLoop for MSW
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 #if wxUSE_GUI
29 #include "wx/window.h"
30 #endif
31 #include "wx/app.h"
32 #endif //WX_PRECOMP
33
34 #include "wx/evtloop.h"
35 #include "wx/thread.h"
36 #include "wx/except.h"
37 #include "wx/ptr_scpd.h"
38 #include "wx/msw/private.h"
39
40 #if wxUSE_GUI
41 #include "wx/tooltip.h"
42 #if wxUSE_THREADS
43 // define the list of MSG strutures
44 WX_DECLARE_LIST(MSG, wxMsgList);
45
46 #include "wx/listimpl.cpp"
47
48 WX_DEFINE_LIST(wxMsgList)
49 #endif // wxUSE_THREADS
50 #endif //wxUSE_GUI
51
52 #if wxUSE_BASE
53
54 // ============================================================================
55 // wxMSWEventLoopBase implementation
56 // ============================================================================
57
58 // ----------------------------------------------------------------------------
59 // ctor/dtor
60 // ----------------------------------------------------------------------------
61
62 wxMSWEventLoopBase::wxMSWEventLoopBase()
63 {
64 m_shouldExit = false;
65 m_exitcode = 0;
66 }
67
68 // ----------------------------------------------------------------------------
69 // wxEventLoop message processing dispatching
70 // ----------------------------------------------------------------------------
71
72 bool wxMSWEventLoopBase::Pending() const
73 {
74 MSG msg;
75 return ::PeekMessage(&msg, 0, 0, 0, PM_NOREMOVE) != 0;
76 }
77
78 bool wxMSWEventLoopBase::GetNextMessage(WXMSG* msg)
79 {
80 wxCHECK_MSG( IsRunning(), false, _T("can't get messages if not running") );
81
82 const BOOL rc = ::GetMessage(msg, NULL, 0, 0);
83
84 if ( rc == 0 )
85 {
86 // got WM_QUIT
87 return false;
88 }
89
90 if ( rc == -1 )
91 {
92 // should never happen, but let's test for it nevertheless
93 wxLogLastError(wxT("GetMessage"));
94
95 // still break from the loop
96 return false;
97 }
98
99 return true;
100 }
101
102 int wxMSWEventLoopBase::GetNextMessageTimeout(WXMSG *msg, unsigned long timeout)
103 {
104 // MsgWaitForMultipleObjects() won't notice any input which was already
105 // examined (e.g. using PeekMessage()) but not yet removed from the queue
106 // so we need to remove any immediately messages manually
107 //
108 // NB: using MsgWaitForMultipleObjectsEx() could simplify the code here but
109 // it is not available in very old Windows versions
110 if ( !::PeekMessage(msg, 0, 0, 0, PM_REMOVE) )
111 {
112 // we use this function just in order to not block longer than the
113 // given timeout, so we don't pass any handles to it at all
114 if ( ::MsgWaitForMultipleObjects
115 (
116 0, NULL,
117 FALSE,
118 timeout,
119 QS_ALLINPUT
120 ) == WAIT_TIMEOUT )
121 {
122 return -1;
123 }
124
125 if ( !::PeekMessage(msg, 0, 0, 0, PM_REMOVE) )
126 {
127 wxFAIL_MSG( _T("PeekMessage() should have succeeded") );
128
129 return -1;
130 }
131 }
132
133 return msg->message != WM_QUIT;
134 }
135
136
137 #endif // wxUSE_BASE
138
139 #if wxUSE_GUI
140
141 // ============================================================================
142 // GUI wxEventLoop implementation
143 // ============================================================================
144
145 wxWindowMSW *wxGUIEventLoop::ms_winCritical = NULL;
146
147 bool wxGUIEventLoop::IsChildOfCriticalWindow(wxWindowMSW *win)
148 {
149 while ( win )
150 {
151 if ( win == ms_winCritical )
152 return true;
153
154 win = win->GetParent();
155 }
156
157 return false;
158 }
159
160 bool wxGUIEventLoop::PreProcessMessage(WXMSG *msg)
161 {
162 HWND hwnd = msg->hwnd;
163 wxWindow *wndThis = wxGetWindowFromHWND((WXHWND)hwnd);
164 wxWindow *wnd;
165
166 // this might happen if we're in a modeless dialog, or if a wx control has
167 // children which themselves were not created by wx (i.e. wxActiveX control children)
168 if ( !wndThis )
169 {
170 while ( hwnd && (::GetWindowLong(hwnd, GWL_STYLE) & WS_CHILD ))
171 {
172 hwnd = ::GetParent(hwnd);
173
174 // If the control has a wx parent, break and give the parent a chance
175 // to process the window message
176 wndThis = wxGetWindowFromHWND((WXHWND)hwnd);
177 if (wndThis != NULL)
178 break;
179 }
180
181 if ( !wndThis )
182 {
183 // this may happen if the event occurred in a standard modeless dialog (the
184 // only example of which I know of is the find/replace dialog) - then call
185 // IsDialogMessage() to make TAB navigation in it work
186
187 // NOTE: IsDialogMessage() just eats all the messages (i.e. returns true for
188 // them) if we call it for the control itself
189 return hwnd && ::IsDialogMessage(hwnd, msg) != 0;
190 }
191 }
192
193 if ( !AllowProcessing(wndThis) )
194 {
195 // not a child of critical window, so we eat the event but take care to
196 // stop an endless stream of WM_PAINTs which would have resulted if we
197 // didn't validate the invalidated part of the window
198 if ( msg->message == WM_PAINT )
199 ::ValidateRect(hwnd, NULL);
200
201 return true;
202 }
203
204 #if wxUSE_TOOLTIPS
205 // we must relay WM_MOUSEMOVE events to the tooltip ctrl if we want it to
206 // popup the tooltip bubbles
207 if ( msg->message == WM_MOUSEMOVE )
208 {
209 // we should do it if one of window children has an associated tooltip
210 // (and not just if the window has a tooltip itself)
211 if ( wndThis->HasToolTips() )
212 wxToolTip::RelayEvent((WXMSG *)msg);
213 }
214 #endif // wxUSE_TOOLTIPS
215
216 // allow the window to prevent certain messages from being
217 // translated/processed (this is currently used by wxTextCtrl to always
218 // grab Ctrl-C/V/X, even if they are also accelerators in some parent)
219 if ( !wndThis->MSWShouldPreProcessMessage((WXMSG *)msg) )
220 {
221 return false;
222 }
223
224 // try translations first: the accelerators override everything
225 for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
226 {
227 if ( wnd->MSWTranslateMessage((WXMSG *)msg))
228 return true;
229
230 // stop at first top level window, i.e. don't try to process the key
231 // strokes originating in a dialog using the accelerators of the parent
232 // frame - this doesn't make much sense
233 if ( wnd->IsTopLevel() )
234 break;
235 }
236
237 // now try the other hooks (kbd navigation is handled here)
238 for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
239 {
240 if ( wnd->MSWProcessMessage((WXMSG *)msg) )
241 return true;
242
243 // also stop at first top level window here, just as above because
244 // if we don't do this, pressing ESC on a modal dialog shown as child
245 // of a modal dialog with wxID_CANCEL will cause the parent dialog to
246 // be closed, for example
247 if ( wnd->IsTopLevel() )
248 break;
249 }
250
251 // no special preprocessing for this message, dispatch it normally
252 return false;
253 }
254
255 void wxGUIEventLoop::ProcessMessage(WXMSG *msg)
256 {
257 // give us the chance to preprocess the message first
258 if ( !PreProcessMessage(msg) )
259 {
260 // if it wasn't done, dispatch it to the corresponding window
261 ::TranslateMessage(msg);
262 ::DispatchMessage(msg);
263 }
264 }
265
266 bool wxGUIEventLoop::Dispatch()
267 {
268 MSG msg;
269 if ( !GetNextMessage(&msg) )
270 return false;
271
272 #if wxUSE_THREADS
273 wxASSERT_MSG( wxThread::IsMain(),
274 wxT("only the main thread can process Windows messages") );
275
276 static bool s_hadGuiLock = true;
277 static wxMsgList s_aSavedMessages;
278
279 // if a secondary thread owning the mutex is doing GUI calls, save all
280 // messages for later processing - we can't process them right now because
281 // it will lead to recursive library calls (and we're not reentrant)
282 if ( !wxGuiOwnedByMainThread() )
283 {
284 s_hadGuiLock = false;
285
286 // leave out WM_COMMAND messages: too dangerous, sometimes
287 // the message will be processed twice
288 if ( !wxIsWaitingForThread() || msg.message != WM_COMMAND )
289 {
290 MSG* pMsg = new MSG(msg);
291 s_aSavedMessages.Append(pMsg);
292 }
293
294 return true;
295 }
296 else
297 {
298 // have we just regained the GUI lock? if so, post all of the saved
299 // messages
300 //
301 // FIXME of course, it's not _exactly_ the same as processing the
302 // messages normally - expect some things to break...
303 if ( !s_hadGuiLock )
304 {
305 s_hadGuiLock = true;
306
307 wxMsgList::compatibility_iterator node = s_aSavedMessages.GetFirst();
308 while (node)
309 {
310 MSG* pMsg = node->GetData();
311 s_aSavedMessages.Erase(node);
312
313 ProcessMessage(pMsg);
314 delete pMsg;
315
316 node = s_aSavedMessages.GetFirst();
317 }
318 }
319 }
320 #endif // wxUSE_THREADS
321
322 ProcessMessage(&msg);
323
324 return true;
325 }
326
327 int wxGUIEventLoop::DispatchTimeout(unsigned long timeout)
328 {
329 MSG msg;
330 int rc = GetNextMessageTimeout(&msg, timeout);
331 if ( rc != 1 )
332 return rc;
333
334 ProcessMessage(&msg);
335
336 return 1;
337 }
338
339 void wxGUIEventLoop::OnNextIteration()
340 {
341 #if wxUSE_THREADS
342 wxMutexGuiLeaveOrEnter();
343 #endif // wxUSE_THREADS
344 }
345
346 void wxGUIEventLoop::WakeUp()
347 {
348 ::PostMessage(NULL, WM_NULL, 0, 0);
349 }
350
351 #else // !wxUSE_GUI
352
353 #if wxUSE_CONSOLE_EVENTLOOP
354
355 void wxConsoleEventLoop::OnNextIteration()
356 {
357 if ( wxTheApp )
358 wxTheApp->ProcessPendingEvents();
359 }
360
361 void wxConsoleEventLoop::WakeUp()
362 {
363 #if wxUSE_THREADS
364 wxWakeUpMainThread();
365 #endif
366 }
367
368 void wxConsoleEventLoop::ProcessMessage(WXMSG *msg)
369 {
370 if ( msg->message == WM_TIMER )
371 {
372 TIMERPROC proc = (TIMERPROC)msg->lParam;
373 if ( proc )
374 (*proc)(NULL, 0, msg->wParam, 0);
375 }
376 else
377 {
378 ::DispatchMessage(msg);
379 }
380 }
381
382 bool wxConsoleEventLoop::Dispatch()
383 {
384 MSG msg;
385 if ( !GetNextMessage(&msg) )
386 return false;
387
388 ProcessMessage(&msg);
389
390 return !m_shouldExit;
391 }
392
393 int wxConsoleEventLoop::DispatchTimeout(unsigned long timeout)
394 {
395 MSG msg;
396 int rc = GetNextMessageTimeout(&msg, timeout);
397 if ( rc != 1 )
398 return rc;
399
400 ProcessMessage(&msg);
401
402 return !m_shouldExit;
403 }
404
405 #endif // wxUSE_CONSOLE_EVENTLOOP
406
407 #endif //wxUSE_GUI