]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/evtloop.cpp
Remove support for Gnome printing from wxGTK.
[wxWidgets.git] / src / gtk / evtloop.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/evtloop.cpp
3 // Purpose: implements wxEventLoop for GTK+
4 // Author: Vadim Zeitlin
5 // Created: 10.07.01
6 // Copyright: (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
7 // (c) 2013 Rob Bresalier, Vadim Zeitlin
8 // Licence: wxWindows licence
9 ///////////////////////////////////////////////////////////////////////////////
10
11 // ============================================================================
12 // declarations
13 // ============================================================================
14
15 // ----------------------------------------------------------------------------
16 // headers
17 // ----------------------------------------------------------------------------
18
19 // For compilers that support precompilation, includes "wx.h".
20 #include "wx/wxprec.h"
21
22 #ifdef __BORLANDC__
23 #pragma hdrstop
24 #endif
25
26 #include "wx/evtloop.h"
27 #include "wx/evtloopsrc.h"
28
29 #ifndef WX_PRECOMP
30 #include "wx/app.h"
31 #include "wx/log.h"
32 #endif // WX_PRECOMP
33
34 #include "wx/private/eventloopsourcesmanager.h"
35 #include "wx/apptrait.h"
36
37 #include <gtk/gtk.h>
38 #include <glib.h>
39
40 // ============================================================================
41 // wxEventLoop implementation
42 // ============================================================================
43
44 extern GtkWidget *wxGetRootWindow();
45
46 // ----------------------------------------------------------------------------
47 // wxEventLoop running and exiting
48 // ----------------------------------------------------------------------------
49
50 wxGUIEventLoop::wxGUIEventLoop()
51 {
52 m_exitcode = 0;
53 }
54
55 int wxGUIEventLoop::DoRun()
56 {
57 guint loopLevel = gtk_main_level();
58
59 // This is placed inside of a loop to take into account nested
60 // event loops. For example, inside this event loop, we may receive
61 // Exit() for a different event loop (which we are currently inside of)
62 // That Exit() will cause this gtk_main() to exit so we need to re-enter it.
63 while ( !m_shouldExit )
64 {
65 gtk_main();
66 }
67
68 // Force the enclosing event loop to also exit to see if it is done in case
69 // that event loop had Exit() called inside of the just ended loop. If it
70 // is not time yet for that event loop to exit, it will be executed again
71 // due to the while() loop on m_shouldExit().
72 //
73 // This is unnecessary if we are the top level loop, i.e. loop of level 0.
74 if ( loopLevel )
75 {
76 gtk_main_quit();
77 }
78
79 OnExit();
80
81 return m_exitcode;
82 }
83
84 void wxGUIEventLoop::ScheduleExit(int rc)
85 {
86 wxCHECK_RET( IsInsideRun(), wxT("can't call ScheduleExit() if not started") );
87
88 m_exitcode = rc;
89
90 m_shouldExit = true;
91
92 gtk_main_quit();
93 }
94
95 void wxGUIEventLoop::WakeUp()
96 {
97 // TODO: idle events handling should really be done by wxEventLoop itself
98 // but for now it's completely in gtk/app.cpp so just call there when
99 // we have wxTheApp and hope that it doesn't matter that we do
100 // nothing when we don't...
101 if ( wxTheApp )
102 wxTheApp->WakeUpIdle();
103 }
104
105 // ----------------------------------------------------------------------------
106 // wxEventLoop adding & removing sources
107 // ----------------------------------------------------------------------------
108
109 #if wxUSE_EVENTLOOP_SOURCE
110
111 extern "C"
112 {
113 static gboolean wx_on_channel_event(GIOChannel *channel,
114 GIOCondition condition,
115 gpointer data)
116 {
117 wxUnusedVar(channel); // Unused if !wxUSE_LOG || !wxDEBUG_LEVEL
118
119 wxLogTrace(wxTRACE_EVT_SOURCE,
120 "wx_on_channel_event, fd=%d, condition=%08x",
121 g_io_channel_unix_get_fd(channel), condition);
122
123 wxEventLoopSourceHandler * const
124 handler = static_cast<wxEventLoopSourceHandler *>(data);
125
126 if ( (condition & G_IO_IN) || (condition & G_IO_PRI) || (condition & G_IO_HUP) )
127 handler->OnReadWaiting();
128
129 if (condition & G_IO_OUT)
130 handler->OnWriteWaiting();
131
132 if ( (condition & G_IO_ERR) || (condition & G_IO_NVAL) )
133 handler->OnExceptionWaiting();
134
135 // we never want to remove source here, so always return true
136 //
137 // The source may have been removed by the handler, so it may be
138 // a good idea to return FALSE when the source has already been
139 // removed. However, that would involve somehow informing this function
140 // that the source was removed, which is not trivial to implement
141 // and handle all cases. It has been found through testing
142 // that if the source was removed by the handler, that even if we
143 // return TRUE here, the source/callback will not get called again.
144 return TRUE;
145 }
146 }
147
148 class wxGUIEventLoopSourcesManager : public wxEventLoopSourcesManagerBase
149 {
150 public:
151 virtual wxEventLoopSource*
152 AddSourceForFD(int fd, wxEventLoopSourceHandler *handler, int flags)
153 {
154 wxCHECK_MSG( fd != -1, NULL, "can't monitor invalid fd" );
155
156 int condition = 0;
157 if ( flags & wxEVENT_SOURCE_INPUT )
158 condition |= G_IO_IN | G_IO_PRI | G_IO_HUP;
159 if ( flags & wxEVENT_SOURCE_OUTPUT )
160 condition |= G_IO_OUT;
161 if ( flags & wxEVENT_SOURCE_EXCEPTION )
162 condition |= G_IO_ERR | G_IO_NVAL;
163
164 GIOChannel* channel = g_io_channel_unix_new(fd);
165 const unsigned sourceId = g_io_add_watch
166 (
167 channel,
168 (GIOCondition)condition,
169 &wx_on_channel_event,
170 handler
171 );
172 // it was ref'd by g_io_add_watch() so we can unref it here
173 g_io_channel_unref(channel);
174
175 if ( !sourceId )
176 return NULL;
177
178 wxLogTrace(wxTRACE_EVT_SOURCE,
179 "Adding event loop source for fd=%d with GTK id=%u",
180 fd, sourceId);
181
182
183 return new wxGTKEventLoopSource(sourceId, handler, flags);
184 }
185 };
186
187 wxEventLoopSourcesManagerBase* wxGUIAppTraits::GetEventLoopSourcesManager()
188 {
189 static wxGUIEventLoopSourcesManager s_eventLoopSourcesManager;
190
191 return &s_eventLoopSourcesManager;
192 }
193
194 wxGTKEventLoopSource::~wxGTKEventLoopSource()
195 {
196 wxLogTrace(wxTRACE_EVT_SOURCE,
197 "Removing event loop source with GTK id=%u", m_sourceId);
198
199 g_source_remove(m_sourceId);
200 }
201
202 #endif // wxUSE_EVENTLOOP_SOURCE
203
204 // ----------------------------------------------------------------------------
205 // wxEventLoop message processing dispatching
206 // ----------------------------------------------------------------------------
207
208 bool wxGUIEventLoop::Pending() const
209 {
210 if ( wxTheApp )
211 {
212 // this avoids false positives from our idle source
213 return wxTheApp->EventsPending();
214 }
215
216 return gtk_events_pending() != 0;
217 }
218
219 bool wxGUIEventLoop::Dispatch()
220 {
221 wxCHECK_MSG( IsRunning(), false, wxT("can't call Dispatch() if not running") );
222
223 // gtk_main_iteration() returns TRUE only if gtk_main_quit() was called
224 return !gtk_main_iteration();
225 }
226
227 extern "C" {
228 static gboolean wx_event_loop_timeout(void* data)
229 {
230 bool* expired = static_cast<bool*>(data);
231 *expired = true;
232
233 // return FALSE to remove this timeout
234 return FALSE;
235 }
236 }
237
238 int wxGUIEventLoop::DispatchTimeout(unsigned long timeout)
239 {
240 bool expired = false;
241 const unsigned id = g_timeout_add(timeout, wx_event_loop_timeout, &expired);
242 bool quit = gtk_main_iteration() != 0;
243
244 if ( expired )
245 return -1;
246
247 g_source_remove(id);
248
249 return !quit;
250 }
251
252 //-----------------------------------------------------------------------------
253 // YieldFor
254 //-----------------------------------------------------------------------------
255
256 extern "C" {
257 static void wxgtk_main_do_event(GdkEvent* event, void* data)
258 {
259 // categorize the GDK event according to wxEventCategory.
260 // See http://library.gnome.org/devel/gdk/unstable/gdk-Events.html#GdkEventType
261 // for more info.
262
263 // NOTE: GDK_* constants which were not present in the GDK2.0 can be tested for
264 // only at compile-time; when running the program (compiled with a recent GDK)
265 // on a system with an older GDK lib we can be sure there won't be problems
266 // because event->type will never assume those values corresponding to
267 // new event types (since new event types are always added in GDK with non
268 // conflicting values for ABI compatibility).
269
270 // Some events (currently only a single one) may be used for more than one
271 // category, so we need 2 variables. The second one will remain "unknown"
272 // in most cases.
273 wxEventCategory cat = wxEVT_CATEGORY_UNKNOWN,
274 cat2 = wxEVT_CATEGORY_UNKNOWN;
275 switch (event->type)
276 {
277 case GDK_SELECTION_REQUEST:
278 case GDK_SELECTION_NOTIFY:
279 case GDK_SELECTION_CLEAR:
280 case GDK_OWNER_CHANGE:
281 cat = wxEVT_CATEGORY_CLIPBOARD;
282 break;
283
284 case GDK_KEY_PRESS:
285 case GDK_KEY_RELEASE:
286 case GDK_BUTTON_PRESS:
287 case GDK_2BUTTON_PRESS:
288 case GDK_3BUTTON_PRESS:
289 case GDK_BUTTON_RELEASE:
290 case GDK_SCROLL: // generated from mouse buttons
291 case GDK_CLIENT_EVENT:
292 cat = wxEVT_CATEGORY_USER_INPUT;
293 break;
294
295 case GDK_PROPERTY_NOTIFY:
296 // This one is special: it can be used for UI purposes but also for
297 // clipboard operations, so allow it in both cases (we probably could
298 // examine the event itself to distinguish between the two cases but
299 // this would be unnecessarily complicated).
300 cat2 = wxEVT_CATEGORY_CLIPBOARD;
301 // Fall through.
302
303 case GDK_PROXIMITY_IN:
304 case GDK_PROXIMITY_OUT:
305
306 case GDK_MOTION_NOTIFY:
307 case GDK_ENTER_NOTIFY:
308 case GDK_LEAVE_NOTIFY:
309 case GDK_VISIBILITY_NOTIFY:
310
311 case GDK_FOCUS_CHANGE:
312 case GDK_CONFIGURE:
313 case GDK_WINDOW_STATE:
314 case GDK_SETTING:
315 case GDK_DELETE:
316 case GDK_DESTROY:
317
318 case GDK_EXPOSE:
319 #ifndef __WXGTK3__
320 case GDK_NO_EXPOSE:
321 #endif
322 case GDK_MAP:
323 case GDK_UNMAP:
324
325 case GDK_DRAG_ENTER:
326 case GDK_DRAG_LEAVE:
327 case GDK_DRAG_MOTION:
328 case GDK_DRAG_STATUS:
329 case GDK_DROP_START:
330 case GDK_DROP_FINISHED:
331 #if GTK_CHECK_VERSION(2,8,0)
332 case GDK_GRAB_BROKEN:
333 #endif
334 #if GTK_CHECK_VERSION(2,14,0)
335 case GDK_DAMAGE:
336 #endif
337 cat = wxEVT_CATEGORY_UI;
338 break;
339
340 default:
341 cat = wxEVT_CATEGORY_UNKNOWN;
342 break;
343 }
344
345 wxGUIEventLoop* evtloop = static_cast<wxGUIEventLoop*>(data);
346
347 // is this event allowed now?
348 if (evtloop->IsEventAllowedInsideYield(cat) ||
349 (cat2 != wxEVT_CATEGORY_UNKNOWN &&
350 evtloop->IsEventAllowedInsideYield(cat2)))
351 {
352 // process it now
353 gtk_main_do_event(event);
354 }
355 else if (event->type != GDK_NOTHING)
356 {
357 // process it later (but make a copy; the caller will free the event
358 // pointer)
359 evtloop->StoreGdkEventForLaterProcessing(gdk_event_copy(event));
360 }
361 }
362 }
363
364 bool wxGUIEventLoop::YieldFor(long eventsToProcess)
365 {
366 #if wxUSE_THREADS
367 if ( !wxThread::IsMain() )
368 {
369 // can't call gtk_main_iteration() from other threads like this
370 return true;
371 }
372 #endif // wxUSE_THREADS
373
374 m_isInsideYield = true;
375 m_eventsToProcessInsideYield = eventsToProcess;
376
377 #if wxUSE_LOG
378 // disable log flushing from here because a call to wxYield() shouldn't
379 // normally result in message boxes popping up &c
380 wxLog::Suspend();
381 #endif
382
383 // temporarily replace the global GDK event handler with our function, which
384 // categorizes the events and using m_eventsToProcessInsideYield decides
385 // if an event should be processed immediately or not
386 // NOTE: this approach is better than using gdk_display_get_event() because
387 // gtk_main_iteration() does more than just calling gdk_display_get_event()
388 // and then call gtk_main_do_event()!
389 // In particular in this way we also process input from sources like
390 // GIOChannels (this is needed for e.g. wxGUIAppTraits::WaitForChild).
391 gdk_event_handler_set(wxgtk_main_do_event, this, NULL);
392 while (Pending()) // avoid false positives from our idle source
393 gtk_main_iteration();
394 gdk_event_handler_set ((GdkEventFunc)gtk_main_do_event, NULL, NULL);
395
396 // Process all pending events too, this is consistent with wxMSW behaviour
397 // and the behaviour of wxGTK itself in the previous versions.
398 if ( wxTheApp )
399 wxTheApp->ProcessPendingEvents();
400
401 if (eventsToProcess != wxEVT_CATEGORY_CLIPBOARD)
402 {
403 // It's necessary to call ProcessIdle() to update the frames sizes which
404 // might have been changed (it also will update other things set from
405 // OnUpdateUI() which is a nice (and desired) side effect). But we
406 // call ProcessIdle() only once since this is not meant for longish
407 // background jobs (controlled by wxIdleEvent::RequestMore() and the
408 // return value of Processidle().
409 ProcessIdle();
410 }
411 //else: if we are inside ~wxClipboardSync() and we call ProcessIdle() and
412 // the user app contains an UI update handler which calls wxClipboard::IsSupported,
413 // then we fall into a never-ending loop...
414
415 // put all unprocessed GDK events back in the queue
416 GdkDisplay* disp = gtk_widget_get_display(wxGetRootWindow());
417 for (size_t i=0; i<m_arrGdkEvents.GetCount(); i++)
418 {
419 GdkEvent* ev = (GdkEvent*)m_arrGdkEvents[i];
420
421 // NOTE: gdk_display_put_event makes a copy of the event passed to it
422 gdk_display_put_event(disp, ev);
423 gdk_event_free(ev);
424 }
425
426 m_arrGdkEvents.Clear();
427
428 #if wxUSE_LOG
429 // let the logs be flashed again
430 wxLog::Resume();
431 #endif
432
433 m_isInsideYield = false;
434
435 return true;
436 }