]> git.saurik.com Git - wxWidgets.git/blame - src/motif/evtloop.cpp
assert if opening more than one find/replace dialog under the same parent -- this...
[wxWidgets.git] / src / motif / evtloop.cpp
CommitLineData
7e1bcfa8 1///////////////////////////////////////////////////////////////////////////////
355b4d3d 2// Name: src/motif/evtloop.cpp
7e1bcfa8
MB
3// Purpose: implements wxEventLoop for Motif
4// Author: Mattia Barbon
5// Modified by:
6// Created: 01.11.02
7// RCS-ID: $Id$
8// Copyright: (c) 2002 Mattia Barbon
65571936 9// License: wxWindows licence
7e1bcfa8
MB
10///////////////////////////////////////////////////////////////////////////////
11
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
7e1bcfa8
MB
20#ifdef __VMS
21#define XtParent XTPARENT
22#define XtDisplay XTDISPLAY
23#endif
24
25// For compilers that support precompilation, includes "wx.h".
26#include "wx/wxprec.h"
27
28#ifndef WX_PRECOMP
29#endif //WX_PRECOMP
30
31#include "wx/evtloop.h"
32#include "wx/event.h"
33#include "wx/app.h"
d8d18184 34#include "wx/window.h"
7e1bcfa8
MB
35
36#ifdef __VMS__
37#pragma message disable nosimpint
38#endif
39#include <Xm/Xm.h>
40#include <X11/Xlib.h>
41#ifdef __VMS__
42#pragma message enable nosimpint
43#endif
44
17a1ebd1 45#include "wx/unix/private.h"
7e1bcfa8
MB
46#include "wx/motif/private.h"
47
48static bool CheckForKeyUp(XEvent* event);
49static bool CheckForKeyDown(XEvent* event);
50static bool CheckForAccelerator(XEvent* event);
51static void ProcessXEvent(XEvent* event);
52static void wxBreakDispatch();
53
54// ----------------------------------------------------------------------------
55// wxEventLoopImpl
56// ----------------------------------------------------------------------------
57
58class WXDLLEXPORT wxEventLoopImpl
59{
60public:
61 // ctor
62 wxEventLoopImpl() { SetExitCode(0); }
63
64 // set/get the exit code
65 void SetExitCode(int exitcode) { m_exitcode = exitcode; }
66 int GetExitCode() const { return m_exitcode; }
67
68 bool SendIdleMessage();
69 bool GetKeepGoing() const { return m_keepGoing; }
70 void SetKeepGoing(bool keepGoing) { m_keepGoing = keepGoing; }
71private:
72 // the exit code of the event loop
73 int m_exitcode;
74 bool m_keepGoing;
75};
76
77// ----------------------------------------------------------------------------
78// wxEventLoopImpl idle event processing
79// ----------------------------------------------------------------------------
80
81static bool SendIdleMessage()
82{
df7f0a04 83 return wxTheApp->ProcessIdle();
7e1bcfa8
MB
84}
85
86bool wxEventLoopImpl::SendIdleMessage()
87{
88 return ::SendIdleMessage();
89}
90
91// ============================================================================
92// wxEventLoop implementation
93// ============================================================================
94
95// ----------------------------------------------------------------------------
96// wxEventLoop running and exiting
97// ----------------------------------------------------------------------------
98
3754265e 99wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL;
7e1bcfa8
MB
100
101wxEventLoop::~wxEventLoop()
102{
103 wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
104}
105
7e1bcfa8
MB
106int wxEventLoop::Run()
107{
108 // event loops are not recursive, you need to create another loop!
109 wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
110
111 wxEventLoop *oldLoop = ms_activeLoop;
112 ms_activeLoop = this;
113
114 m_impl = new wxEventLoopImpl;
115 m_impl->SetKeepGoing( true );
116
117 for( ;; )
118 {
119 if( !wxDoEventLoopIteration( *this ) )
120 break;
121 }
122
123 int exitcode = m_impl->GetExitCode();
124 delete m_impl;
125 m_impl = NULL;
126
127 ms_activeLoop = oldLoop;
128
129 return exitcode;
130}
131
132void wxEventLoop::Exit(int rc)
133{
134 wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
135
136 m_impl->SetExitCode(rc);
137 m_impl->SetKeepGoing( false );
138
139 ::wxBreakDispatch();
140}
141
142// ----------------------------------------------------------------------------
143// wxEventLoop message processing dispatching
144// ----------------------------------------------------------------------------
145
146bool wxEventLoop::Pending() const
147{
148 return XtAppPending( (XtAppContext)wxTheApp->GetAppContext() ) != 0;
149}
150
151bool wxEventLoop::Dispatch()
152{
153 XEvent event;
154 XtAppContext context = (XtAppContext)wxTheApp->GetAppContext();
155
156 if( XtAppPeekEvent( context, &event ) != 0 )
157 {
158 XtAppNextEvent( context, &event );
159 ProcessXEvent( &event );
160 }
161 else
5e23e2d5
VZ
162 {
163 XtAppProcessEvent( context, XtIMTimer | XtIMAlternateInput
164#ifdef XtIMSignal
165 | XtIMSignal
bf91e652 166#endif
5e23e2d5
VZ
167 );
168 }
369da724 169
7e1bcfa8
MB
170 return m_impl ? m_impl->GetKeepGoing() : true;
171}
172
173// ----------------------------------------------------------------------------
174// Static functions (originally in app.cpp)
175// ----------------------------------------------------------------------------
176
177void ProcessXEvent(XEvent* event)
178{
179 if (event->type == KeyPress)
180 {
181 if (CheckForAccelerator(event))
182 {
183 // Do nothing! We intercepted and processed the event as an
184 // accelerator.
185 return;
186 }
187 // It seemed before that this hack was redundant and
188 // key down events were being generated by wxCanvasInputEvent.
189 // But no longer - why ???
190 //
191 else if (CheckForKeyDown(event))
192 {
193 // We intercepted and processed the key down event
194 return;
195 }
196 else
197 {
198 XtDispatchEvent(event);
199 return;
200 }
201 }
202 else if (event->type == KeyRelease)
203 {
204 // TODO: work out why we still need this ! -michael
205 //
206 if (::CheckForKeyUp(event))
207 {
208 // We intercepted and processed the key up event
209 return;
210 }
211 else
212 {
213 XtDispatchEvent(event);
214 return;
215 }
216 }
217 else if (event->type == PropertyNotify)
218 {
219 wxTheApp->HandlePropertyChange(event);
220 return;
221 }
222 else if (event->type == ResizeRequest)
223 {
224 /* Terry Gitnick <terryg@scientech.com> - 1/21/98
225 * If resize event, don't resize until the last resize event for this
226 * window is recieved. Prevents flicker as windows are resized.
227 */
228
eb6fa4b4 229 Display *disp = event->xany.display;
7e1bcfa8
MB
230 Window win = event->xany.window;
231 XEvent report;
232
233 // to avoid flicker
234 report = * event;
235 while( XCheckTypedWindowEvent (disp, win, ResizeRequest, &report));
236
237 // TODO: when implementing refresh optimization, we can use
238 // XtAddExposureToRegion to expand the window's paint region.
239
240 XtDispatchEvent(event);
241 }
242 else
243 {
244 XtDispatchEvent(event);
245 }
246}
247
248// Returns true if an accelerator has been processed
249bool CheckForAccelerator(XEvent* event)
250{
251 if (event->xany.type == KeyPress)
252 {
253 // Find a wxWindow for this window
254 // TODO: should get display for the window, not the current display
eb6fa4b4 255 Widget widget = XtWindowToWidget(event->xany.display,
7e1bcfa8
MB
256 event->xany.window);
257 wxWindow* win = NULL;
258
259 // Find the first wxWindow that corresponds to this event window
355b4d3d 260 while (widget && ((win = wxGetWindowFromTable(widget))!=NULL))
7e1bcfa8
MB
261 widget = XtParent(widget);
262
263 if (!widget || !win)
264 return false;
265
266 wxKeyEvent keyEvent(wxEVT_CHAR);
267 wxTranslateKeyEvent(keyEvent, win, (Widget) 0, event);
268
269 // Now we have a wxKeyEvent and we have a wxWindow.
270 // Go up the hierarchy until we find a matching accelerator,
271 // or we get to the top.
272 while (win)
273 {
274 if (win->ProcessAccelerator(keyEvent))
275 return true;
276 win = win->GetParent();
277 }
278 return false;
279 }
280 return false;
281}
282
283// bool wxApp::CheckForKeyDown(WXEvent* event) { wxFAIL; return false; }
284
285bool CheckForKeyDown(XEvent* event)
286{
287 if (event->xany.type == KeyPress)
288 {
eb6fa4b4
MB
289 Widget widget = XtWindowToWidget(event->xany.display,
290 event->xany.window);
7e1bcfa8
MB
291 wxWindow* win = NULL;
292
293 // Find the first wxWindow that corresponds to this event window
355b4d3d 294 while (widget && ((win = wxGetWindowFromTable(widget))!=NULL))
7e1bcfa8
MB
295 widget = XtParent(widget);
296
297 if (!widget || !win)
298 return false;
299
300 wxKeyEvent keyEvent(wxEVT_KEY_DOWN);
301 wxTranslateKeyEvent(keyEvent, win, (Widget) 0, event);
302
44f5b995 303 return win->GetEventHandler()->ProcessEvent( keyEvent );
7e1bcfa8
MB
304 }
305
306 return false;
307}
308
309// bool wxApp::CheckForKeyUp(WXEvent* event) { wxFAIL; return false; }
310
311bool CheckForKeyUp(XEvent* event)
312{
313 if (event->xany.type == KeyRelease)
314 {
eb6fa4b4
MB
315 Widget widget = XtWindowToWidget(event->xany.display,
316 event->xany.window);
7e1bcfa8
MB
317 wxWindow* win = NULL;
318
319 // Find the first wxWindow that corresponds to this event window
355b4d3d 320 while (widget && ((win = wxGetWindowFromTable(widget))!=NULL))
7e1bcfa8
MB
321 widget = XtParent(widget);
322
323 if (!widget || !win)
324 return false;
325
326 wxKeyEvent keyEvent(wxEVT_KEY_UP);
327 wxTranslateKeyEvent(keyEvent, win, (Widget) 0, event);
328
44f5b995 329 return win->GetEventHandler()->ProcessEvent( keyEvent );
7e1bcfa8
MB
330 }
331
332 return false;
333}
334
335// ----------------------------------------------------------------------------
336// executes one main loop iteration (declared in include/wx/motif/private.h)
337// ----------------------------------------------------------------------------
338
339bool wxDoEventLoopIteration( wxEventLoop& evtLoop )
340{
369da724
MB
341 bool moreRequested, pendingEvents;
342
343 for(;;)
344 {
345 pendingEvents = evtLoop.Pending();
346 if( pendingEvents ) break;
347 moreRequested = ::SendIdleMessage();
348 if( !moreRequested ) break;
349 }
350
7e1bcfa8 351#if wxUSE_THREADS
369da724
MB
352 if( !pendingEvents && !moreRequested )
353 {
354 // leave the main loop to give other threads a chance to
355 // perform their GUI work
356 wxMutexGuiLeave();
27d1f929 357 wxMilliSleep(20);
369da724
MB
358 wxMutexGuiEnter();
359 }
7e1bcfa8
MB
360#endif
361
7e1bcfa8
MB
362 if( !evtLoop.Dispatch() )
363 return false;
364
365 return true;
366}
367
368// ----------------------------------------------------------------------------
369// ::wxWakeUpIdle implementation
370// ----------------------------------------------------------------------------
371
372// As per Vadim's suggestion, we open a pipe, and XtAppAddInputSource it;
373// writing a single byte to the pipe will cause wxEventLoop::Pending
374// to return true, and wxEventLoop::Dispatch to dispatch an input handler
375// that simply removes the byte(s), and to return, which will cause
376// an idle event to be sent
377
378// also wxEventLoop::Exit is implemented that way, so that exiting an
379// event loop won't require an event being in the queue
380
381#include "wx/module.h"
382
383#include <sys/types.h>
384#include <sys/time.h>
385#include <unistd.h>
386
7e1bcfa8
MB
387static int idleFds[2] = { -1, -1 };
388
389class wxIdlePipeModule : public wxModule
390{
391public:
392 wxIdlePipeModule() {};
393
394 virtual bool OnInit()
395 {
74039d33
JS
396 // Must be done before modules are initialized
397#if 0
7e1bcfa8
MB
398 if( pipe(idleFds) != 0 )
399 return false;
74039d33 400#endif
7e1bcfa8
MB
401 return true;
402 }
403
404 virtual void OnExit()
405 {
406 close( idleFds[0] );
407 close( idleFds[1] );
408 }
409private:
bc21780e 410 DECLARE_DYNAMIC_CLASS(wxIdlePipeModule)
7e1bcfa8
MB
411};
412
e933b5bc 413IMPLEMENT_DYNAMIC_CLASS(wxIdlePipeModule, wxModule)
7e1bcfa8
MB
414
415static void wxInputCallback( XtPointer, int* fd, XtInputId* )
416{
417 char buffer[128];
418
419 // wxWakeUpIdle may have been called more than once
420 for(;;)
421 {
422 fd_set in;
423 struct timeval timeout;
424
425 timeout.tv_sec = 0;
426 timeout.tv_usec = 0;
427
17a1ebd1
VZ
428 wxFD_ZERO( &in );
429 wxFD_SET( *fd, &in );
7e1bcfa8
MB
430
431 if( select( *fd + 1, &in, NULL, NULL, &timeout ) <= 0 )
432 break;
433 if( read( *fd, buffer, sizeof(buffer) - 1 ) != sizeof(buffer) - 1 )
434 break;
435 }
436}
437
438static void wxBreakDispatch()
439{
d8d18184 440 char dummy = 0; // for valgrind
7e1bcfa8
MB
441
442 // check if wxWakeUpIdle has already been called
443 fd_set in;
444 struct timeval timeout;
445
446 timeout.tv_sec = 0;
447 timeout.tv_usec = 0;
448
17a1ebd1
VZ
449 wxFD_ZERO( &in );
450 wxFD_SET( idleFds[0], &in );
7e1bcfa8
MB
451
452 if( select( idleFds[0] + 1, &in, NULL, NULL, &timeout ) > 0 )
453 return;
454
455 // write a single byte
456 write( idleFds[1], &dummy, 1 );
457}
458
e2478fde 459void wxApp::WakeUpIdle()
7e1bcfa8
MB
460{
461 ::wxBreakDispatch();
462}
463
74039d33
JS
464bool wxInitIdleFds()
465{
466 if( pipe(idleFds) != 0 )
467 return false;
468 return true;
469}
470
7e1bcfa8
MB
471bool wxAddIdleCallback()
472{
74039d33
JS
473 if (!wxInitIdleFds())
474 return false;
355b4d3d 475
7e1bcfa8 476 // install input handler for wxWakeUpIdle
002ceb38
VZ
477 XtAppAddInput((XtAppContext) wxTheApp->GetAppContext(),
478 idleFds[0],
479 (XtPointer)XtInputReadMask,
480 wxInputCallback,
481 NULL);
7e1bcfa8
MB
482
483 return true;
484}
485