src/gtk/evtloop.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk/evtloop.cpp
   3 // Purpose:     implements wxEventLoop for GTK+
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     10.07.01
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     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 #include "wx/evtloop.h"
  28 #include "wx/evtloopsrc.h"
  29
  30 #ifndef WX_PRECOMP
  31     #include "wx/app.h"
  32     #include "wx/log.h"
  33 #endif // WX_PRECOMP
  34
  35 #include <gtk/gtk.h>
  36 #include <glib.h>
  37
  38 // ============================================================================
  39 // wxEventLoop implementation
  40 // ============================================================================
  41
  42 extern GtkWidget *wxGetRootWindow();
  43
  44 // ----------------------------------------------------------------------------
  45 // wxEventLoop running and exiting
  46 // ----------------------------------------------------------------------------
  47
  48 wxGUIEventLoop::wxGUIEventLoop()
  49 {
  50     m_exitcode = 0;
  51 }
  52
  53 int wxGUIEventLoop::Run()
  54 {
  55     // event loops are not recursive, you need to create another loop!
  56     wxCHECK_MSG( !IsRunning(), -1, "can't reenter a message loop" );
  57
  58     wxEventLoopActivator activate(this);
  59
  60     gtk_main();
  61
  62     OnExit();
  63
  64     return m_exitcode;
  65 }
  66
  67 void wxGUIEventLoop::Exit(int rc)
  68 {
  69     wxCHECK_RET( IsRunning(), "can't call Exit() if not running" );
  70
  71     m_exitcode = rc;
  72
  73     gtk_main_quit();
  74 }
  75
  76 void wxGUIEventLoop::WakeUp()
  77 {
  78     // TODO: idle events handling should really be done by wxEventLoop itself
  79     //       but for now it's completely in gtk/app.cpp so just call there when
  80     //       we have wxTheApp and hope that it doesn't matter that we do
  81     //       nothing when we don't...
  82     if ( wxTheApp )
  83         wxTheApp->WakeUpIdle();
  84 }
  85
  86 // ----------------------------------------------------------------------------
  87 // wxEventLoop adding & removing sources
  88 // ----------------------------------------------------------------------------
  89
  90 #if wxUSE_EVENTLOOP_SOURCE
  91
  92 extern "C"
  93 {
  94 static gboolean wx_on_channel_event(GIOChannel *channel,
  95                                     GIOCondition condition,
  96                                     gpointer data)
  97 {
  98     wxLogTrace(wxTRACE_EVT_SOURCE,
  99                "wx_on_channel_event, fd=%d, condition=%08x",
 100                g_io_channel_unix_get_fd(channel), condition);
 101
 102     wxEventLoopSourceHandler * const
 103         handler = static_cast<wxEventLoopSourceHandler *>(data);
 104
 105     if (condition & G_IO_IN || condition & G_IO_PRI)
 106         handler->OnReadWaiting();
 107     if (condition & G_IO_OUT)
 108         handler->OnWriteWaiting();
 109     else if (condition & G_IO_ERR || condition & G_IO_NVAL)
 110         handler->OnExceptionWaiting();
 111
 112     // we never want to remove source here, so always return true
 113     return TRUE;
 114 }
 115 }
 116
 117 wxEventLoopSource *
 118 wxGUIEventLoop::AddSourceForFD(int fd,
 119                                wxEventLoopSourceHandler *handler,
 120                                int flags)
 121 {
 122     wxCHECK_MSG( fd != -1, NULL, "can't monitor invalid fd" );
 123
 124     int condition = 0;
 125     if (flags & wxEVENT_SOURCE_INPUT)
 126         condition |= G_IO_IN | G_IO_PRI;
 127     if (flags & wxEVENT_SOURCE_OUTPUT)
 128         condition |= G_IO_OUT;
 129     if (flags & wxEVENT_SOURCE_EXCEPTION)
 130         condition |= G_IO_ERR | G_IO_HUP | G_IO_NVAL;
 131
 132     GIOChannel* channel = g_io_channel_unix_new(fd);
 133     const unsigned sourceId  = g_io_add_watch
 134                                (
 135                                 channel,
 136                                 (GIOCondition)condition,
 137                                 &wx_on_channel_event,
 138                                 handler
 139                                );
 140     // it was ref'd by g_io_add_watch() so we can unref it here
 141     g_io_channel_unref(channel);
 142
 143     if ( !sourceId )
 144         return NULL;
 145
 146     wxLogTrace(wxTRACE_EVT_SOURCE,
 147                "Adding event loop source for fd=%d with GTK id=%u",
 148                fd, sourceId);
 149
 150
 151     return new wxGTKEventLoopSource(sourceId, handler, flags);
 152 }
 153
 154 wxGTKEventLoopSource::~wxGTKEventLoopSource()
 155 {
 156     wxLogTrace(wxTRACE_EVT_SOURCE,
 157                "Removing event loop source with GTK id=%u", m_sourceId);
 158
 159     g_source_remove(m_sourceId);
 160 }
 161
 162 #endif // wxUSE_EVENTLOOP_SOURCE
 163
 164 // ----------------------------------------------------------------------------
 165 // wxEventLoop message processing dispatching
 166 // ----------------------------------------------------------------------------
 167
 168 bool wxGUIEventLoop::Pending() const
 169 {
 170     if ( wxTheApp )
 171     {
 172         // this avoids false positives from our idle source
 173         return wxTheApp->EventsPending();
 174     }
 175
 176     return gtk_events_pending() != 0;
 177 }
 178
 179 bool wxGUIEventLoop::Dispatch()
 180 {
 181     wxCHECK_MSG( IsRunning(), false, wxT("can't call Dispatch() if not running") );
 182
 183     // gtk_main_iteration() returns TRUE only if gtk_main_quit() was called
 184     return !gtk_main_iteration();
 185 }
 186
 187 extern "C" {
 188 static gboolean wx_event_loop_timeout(void* data)
 189 {
 190     bool* expired = static_cast<bool*>(data);
 191     *expired = true;
 192
 193     // return FALSE to remove this timeout
 194     return FALSE;
 195 }
 196 }
 197
 198 int wxGUIEventLoop::DispatchTimeout(unsigned long timeout)
 199 {
 200     bool expired = false;
 201     const unsigned id = g_timeout_add(timeout, wx_event_loop_timeout, &expired);
 202     bool quit = gtk_main_iteration() != 0;
 203
 204     if ( expired )
 205         return -1;
 206
 207     g_source_remove(id);
 208
 209     return !quit;
 210 }
 211
 212 //-----------------------------------------------------------------------------
 213 // YieldFor
 214 //-----------------------------------------------------------------------------
 215
 216 extern "C" {
 217 static void wxgtk_main_do_event(GdkEvent* event, void* data)
 218 {
 219     // categorize the GDK event according to wxEventCategory.
 220     // See http://library.gnome.org/devel/gdk/unstable/gdk-Events.html#GdkEventType
 221     // for more info.
 222
 223     // NOTE: GDK_* constants which were not present in the GDK2.0 can be tested for
 224     //       only at compile-time; when running the program (compiled with a recent GDK)
 225     //       on a system with an older GDK lib we can be sure there won't be problems
 226     //       because event->type will never assume those values corresponding to
 227     //       new event types (since new event types are always added in GDK with non
 228     //       conflicting values for ABI compatibility).
 229
 230     wxEventCategory cat = wxEVT_CATEGORY_UNKNOWN;
 231     switch (event->type)
 232     {
 233     case GDK_SELECTION_REQUEST:
 234     case GDK_SELECTION_NOTIFY:
 235     case GDK_SELECTION_CLEAR:
 236 #if GTK_CHECK_VERSION(2,6,0)
 237     case GDK_OWNER_CHANGE:
 238 #endif
 239         cat = wxEVT_CATEGORY_CLIPBOARD;
 240         break;
 241
 242     case GDK_KEY_PRESS:
 243     case GDK_KEY_RELEASE:
 244     case GDK_BUTTON_PRESS:
 245     case GDK_2BUTTON_PRESS:
 246     case GDK_3BUTTON_PRESS:
 247     case GDK_BUTTON_RELEASE:
 248     case GDK_SCROLL:        // generated from mouse buttons
 249     case GDK_CLIENT_EVENT:
 250         cat = wxEVT_CATEGORY_USER_INPUT;
 251         break;
 252
 253     case GDK_PROXIMITY_IN:
 254     case GDK_PROXIMITY_OUT:
 255
 256     case GDK_MOTION_NOTIFY:
 257     case GDK_ENTER_NOTIFY:
 258     case GDK_LEAVE_NOTIFY:
 259     case GDK_VISIBILITY_NOTIFY:
 260     case GDK_PROPERTY_NOTIFY:
 261
 262     case GDK_FOCUS_CHANGE:
 263     case GDK_CONFIGURE:
 264     case GDK_WINDOW_STATE:
 265     case GDK_SETTING:
 266     case GDK_DELETE:
 267     case GDK_DESTROY:
 268
 269     case GDK_EXPOSE:
 270     case GDK_NO_EXPOSE:
 271     case GDK_MAP:
 272     case GDK_UNMAP:
 273
 274     case GDK_DRAG_ENTER:
 275     case GDK_DRAG_LEAVE:
 276     case GDK_DRAG_MOTION:
 277     case GDK_DRAG_STATUS:
 278     case GDK_DROP_START:
 279     case GDK_DROP_FINISHED:
 280 #if GTK_CHECK_VERSION(2,8,0)
 281     case GDK_GRAB_BROKEN:
 282 #endif
 283 #if GTK_CHECK_VERSION(2,14,0)
 284     case GDK_DAMAGE:
 285 #endif
 286         cat = wxEVT_CATEGORY_UI;
 287         break;
 288
 289     default:
 290         cat = wxEVT_CATEGORY_UNKNOWN;
 291         break;
 292     }
 293
 294     wxGUIEventLoop* evtloop = static_cast<wxGUIEventLoop*>(data);
 295
 296     // is this event allowed now?
 297     if (evtloop->IsEventAllowedInsideYield(cat))
 298         gtk_main_do_event(event);         // process it now
 299     else if (event->type != GDK_NOTHING)
 300         evtloop->StoreGdkEventForLaterProcessing(gdk_event_copy(event));
 301             // process it later (but make a copy; the caller will free the event pointer)
 302 }
 303 }
 304
 305 bool wxGUIEventLoop::YieldFor(long eventsToProcess)
 306 {
 307 #if wxUSE_THREADS
 308     if ( !wxThread::IsMain() )
 309     {
 310         // can't call gtk_main_iteration() from other threads like this
 311         return true;
 312     }
 313 #endif // wxUSE_THREADS
 314
 315     m_isInsideYield = true;
 316     m_eventsToProcessInsideYield = eventsToProcess;
 317
 318 #if wxUSE_LOG
 319     // disable log flushing from here because a call to wxYield() shouldn't
 320     // normally result in message boxes popping up &c
 321     wxLog::Suspend();
 322 #endif
 323
 324     // temporarily replace the global GDK event handler with our function, which
 325     // categorizes the events and using m_eventsToProcessInsideYield decides
 326     // if an event should be processed immediately or not
 327     // NOTE: this approach is better than using gdk_display_get_event() because
 328     //       gtk_main_iteration() does more than just calling gdk_display_get_event()
 329     //       and then call gtk_main_do_event()!
 330     //       In particular in this way we also process input from sources like
 331     //       GIOChannels (this is needed for e.g. wxGUIAppTraits::WaitForChild).
 332     gdk_event_handler_set(wxgtk_main_do_event, this, NULL);
 333     while (Pending())   // avoid false positives from our idle source
 334         gtk_main_iteration();
 335     gdk_event_handler_set ((GdkEventFunc)gtk_main_do_event, NULL, NULL);
 336
 337     if (eventsToProcess != wxEVT_CATEGORY_CLIPBOARD)
 338     {
 339         // It's necessary to call ProcessIdle() to update the frames sizes which
 340         // might have been changed (it also will update other things set from
 341         // OnUpdateUI() which is a nice (and desired) side effect). But we
 342         // call ProcessIdle() only once since this is not meant for longish
 343         // background jobs (controlled by wxIdleEvent::RequestMore() and the
 344         // return value of Processidle().
 345         ProcessIdle();      // ProcessIdle() also calls ProcessPendingEvents()
 346     }
 347     //else: if we are inside ~wxClipboardSync() and we call ProcessIdle() and
 348     //      the user app contains an UI update handler which calls wxClipboard::IsSupported,
 349     //      then we fall into a never-ending loop...
 350
 351     // put all unprocessed GDK events back in the queue
 352     GdkDisplay* disp = gtk_widget_get_display(wxGetRootWindow());
 353     for (size_t i=0; i<m_arrGdkEvents.GetCount(); i++)
 354     {
 355         GdkEvent* ev = (GdkEvent*)m_arrGdkEvents[i];
 356
 357         // NOTE: gdk_display_put_event makes a copy of the event passed to it
 358         gdk_display_put_event(disp, ev);
 359         gdk_event_free(ev);
 360     }
 361
 362     m_arrGdkEvents.Clear();
 363
 364 #if wxUSE_LOG
 365     // let the logs be flashed again
 366     wxLog::Resume();
 367 #endif
 368
 369     m_isInsideYield = false;
 370
 371     return true;
 372 }