]> git.saurik.com Git - wxWidgets.git/blob - src/x11/evtloop.cpp
fix should have been mac only
[wxWidgets.git] / src / x11 / evtloop.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/x11/evtloop.cpp
3 // Purpose: implements wxEventLoop for X11
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 01.06.01
7 // RCS-ID: $Id$
8 // Copyright: (c) 2002 Julian Smart
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 #include "wx/evtloop.h"
24
25 #ifndef WX_PRECOMP
26 #include "wx/hash.h"
27 #include "wx/app.h"
28 #include "wx/window.h"
29 #include "wx/module.h"
30 #endif
31
32 #include "wx/private/fdiodispatcher.h"
33 #include "wx/unix/private.h"
34 #include "wx/x11/private.h"
35 #include "wx/generic/private/timer.h"
36
37 #if wxUSE_THREADS
38 #include "wx/thread.h"
39 #endif
40
41 #include <X11/Xlib.h>
42 #include <sys/time.h>
43 #include <unistd.h>
44
45 #ifdef HAVE_SYS_SELECT_H
46 # include <sys/select.h>
47 #endif
48
49 // ----------------------------------------------------------------------------
50 // wxEventLoopImpl
51 // ----------------------------------------------------------------------------
52
53 class WXDLLEXPORT wxEventLoopImpl
54 {
55 public:
56 // ctor
57 wxEventLoopImpl() { SetExitCode(0); m_keepGoing = false; }
58
59 // process an XEvent, return true if it was processed
60 bool ProcessEvent(XEvent* event);
61
62 // generate an idle message, return true if more idle time requested
63 bool SendIdleEvent();
64
65 // set/get the exit code
66 void SetExitCode(int exitcode) { m_exitcode = exitcode; }
67 int GetExitCode() const { return m_exitcode; }
68
69 public:
70 // preprocess an event, return true if processed (i.e. no further
71 // dispatching required)
72 bool PreProcessEvent(XEvent* event);
73
74 // the exit code of the event loop
75 int m_exitcode;
76
77 bool m_keepGoing;
78 };
79
80 // ============================================================================
81 // wxEventLoopImpl implementation
82 // ============================================================================
83
84 // ----------------------------------------------------------------------------
85 // wxEventLoopImpl message processing
86 // ----------------------------------------------------------------------------
87
88 bool wxEventLoopImpl::ProcessEvent(XEvent *event)
89 {
90 // give us the chance to preprocess the message first
91 if ( PreProcessEvent(event) )
92 return true;
93
94 // if it wasn't done, dispatch it to the corresponding window
95 if (wxTheApp)
96 return wxTheApp->ProcessXEvent((WXEvent*) event);
97
98 return false;
99 }
100
101 bool wxEventLoopImpl::PreProcessEvent(XEvent *WXUNUSED(event))
102 {
103 return false;
104 }
105
106 // ----------------------------------------------------------------------------
107 // wxEventLoopImpl idle event processing
108 // ----------------------------------------------------------------------------
109
110 bool wxEventLoopImpl::SendIdleEvent()
111 {
112 return wxTheApp->ProcessIdle();
113 }
114
115 // ============================================================================
116 // wxEventLoop implementation
117 // ============================================================================
118
119 // ----------------------------------------------------------------------------
120 // wxEventLoop running and exiting
121 // ----------------------------------------------------------------------------
122
123 wxGUIEventLoop::~wxGUIEventLoop()
124 {
125 wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
126 }
127
128 int wxGUIEventLoop::Run()
129 {
130 // event loops are not recursive, you need to create another loop!
131 wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
132
133 m_impl = new wxEventLoopImpl;
134
135 wxEventLoopActivator activate(this);
136
137 m_impl->m_keepGoing = true;
138 while ( m_impl->m_keepGoing )
139 {
140 // generate and process idle events for as long as we don't have
141 // anything else to do
142 while ( ! Pending() )
143 {
144 #if wxUSE_TIMER
145 wxGenericTimerImpl::NotifyTimers(); // TODO: is this the correct place for it?
146 #endif
147 if (!m_impl->SendIdleEvent())
148 {
149 // Break out of while loop
150 break;
151 }
152 }
153
154 // a message came or no more idle processing to do, sit in Dispatch()
155 // waiting for the next message
156 if ( !Dispatch() )
157 {
158 break;
159 }
160 }
161
162 OnExit();
163
164 int exitcode = m_impl->GetExitCode();
165 delete m_impl;
166 m_impl = NULL;
167
168 return exitcode;
169 }
170
171 void wxGUIEventLoop::Exit(int rc)
172 {
173 wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
174
175 m_impl->SetExitCode(rc);
176 m_impl->m_keepGoing = false;
177 }
178
179 // ----------------------------------------------------------------------------
180 // wxEventLoop message processing dispatching
181 // ----------------------------------------------------------------------------
182
183 bool wxGUIEventLoop::Pending() const
184 {
185 XFlush( wxGlobalDisplay() );
186 return (XPending( wxGlobalDisplay() ) > 0);
187 }
188
189 bool wxGUIEventLoop::Dispatch()
190 {
191 XEvent event;
192
193 // TODO allowing for threads, as per e.g. wxMSW
194
195 // This now waits until either an X event is received,
196 // or the select times out. So we should now process
197 // wxTimers in a reasonably timely fashion. However it
198 // does also mean that idle processing will happen more
199 // often, so we should probably limit idle processing to
200 // not be repeated more than every N milliseconds.
201
202 if (XPending( wxGlobalDisplay() ) == 0)
203 {
204 #if wxUSE_NANOX
205 GR_TIMEOUT timeout = 10; // Milliseconds
206 // Wait for next event, or timeout
207 GrGetNextEventTimeout(& event, timeout);
208
209 // Fall through to ProcessEvent.
210 // we'll assume that ProcessEvent will just ignore
211 // the event if there was a timeout and no event.
212
213 #else
214 struct timeval tv;
215 tv.tv_sec=0;
216 tv.tv_usec=10000; // TODO make this configurable
217 int fd = ConnectionNumber( wxGlobalDisplay() );
218
219 fd_set readset;
220 fd_set writeset;
221 wxFD_ZERO(&readset);
222 wxFD_ZERO(&writeset);
223 wxFD_SET(fd, &readset);
224
225 if (select( fd+1, &readset, &writeset, NULL, &tv ) != 0)
226 {
227 // An X11 event was pending, get it
228 if (wxFD_ISSET( fd, &readset ))
229 XNextEvent( wxGlobalDisplay(), &event );
230 }
231 #endif
232 }
233 else
234 {
235 XNextEvent( wxGlobalDisplay(), &event );
236 }
237
238 #if wxUSE_SOCKETS
239 // handle any pending socket events:
240 wxFDIODispatcher::DispatchPending();
241 #endif
242
243 (void) m_impl->ProcessEvent( &event );
244 return true;
245 }