Add doc for wxGraphicsContext.Create(), which is a lightweight context with no target...

[wxWidgets.git] / src / gtk / evtloop.cpp

diff --git a/src/gtk/evtloop.cpp b/src/gtk/evtloop.cpp
index 9a5717c06bb7f2e125b9b370e595b0eb17a8d760..cc118104d55a9dceae266e2a3e1e39f42457ab8f 100644 (file)
--- a/src/gtk/evtloop.cpp
+++ b/src/gtk/evtloop.cpp
@@ -6,7 +6,7 @@
 // Created:     10.07.01
 // RCS-ID:      $Id$
 // Copyright:   (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Created:     10.07.01
 // RCS-ID:      $Id$
 // Copyright:   (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>

-// License:     wxWindows licence
+// Licence:     wxWindows licence

 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================


@@ -25,6 +25,7 @@
 #endif
 
 #include "wx/evtloop.h"
 #endif
 
 #include "wx/evtloop.h"

+#include "wx/evtloopsrc.h"

 
 #ifndef WX_PRECOMP
     #include "wx/app.h"
 
 #ifndef WX_PRECOMP
     #include "wx/app.h"


@@ -32,6 +33,7 @@
 #endif // WX_PRECOMP
 
 #include <gtk/gtk.h>
 #endif // WX_PRECOMP
 
 #include <gtk/gtk.h>

+#include <glib.h>

 
 // ============================================================================
 // wxEventLoop implementation
 
 // ============================================================================
 // wxEventLoop implementation


@@ -81,6 +83,86 @@ void wxGUIEventLoop::WakeUp()
         wxTheApp->WakeUpIdle();
 }
 
         wxTheApp->WakeUpIdle();
 }
 

+// ----------------------------------------------------------------------------
+// wxEventLoop adding & removing sources
+// ----------------------------------------------------------------------------
+
+#if wxUSE_EVENTLOOP_SOURCE
+
+extern "C"
+{
+static gboolean wx_on_channel_event(GIOChannel *channel,
+                                    GIOCondition condition,
+                                    gpointer data)
+{
+    wxUnusedVar(channel); // Unused if !wxUSE_LOG || !wxDEBUG_LEVEL
+
+    wxLogTrace(wxTRACE_EVT_SOURCE,
+               "wx_on_channel_event, fd=%d, condition=%08x",
+               g_io_channel_unix_get_fd(channel), condition);
+
+    wxEventLoopSourceHandler * const
+        handler = static_cast<wxEventLoopSourceHandler *>(data);
+
+    if (condition & G_IO_IN || condition & G_IO_PRI)
+        handler->OnReadWaiting();
+    if (condition & G_IO_OUT)
+        handler->OnWriteWaiting();
+    else if (condition & G_IO_ERR || condition & G_IO_NVAL)
+        handler->OnExceptionWaiting();
+
+    // we never want to remove source here, so always return true
+    return TRUE;
+}
+}
+
+wxEventLoopSource *
+wxGUIEventLoop::AddSourceForFD(int fd,
+                               wxEventLoopSourceHandler *handler,
+                               int flags)
+{
+    wxCHECK_MSG( fd != -1, NULL, "can't monitor invalid fd" );
+
+    int condition = 0;
+    if (flags & wxEVENT_SOURCE_INPUT)
+        condition |= G_IO_IN | G_IO_PRI;
+    if (flags & wxEVENT_SOURCE_OUTPUT)
+        condition |= G_IO_OUT;
+    if (flags & wxEVENT_SOURCE_EXCEPTION)
+        condition |= G_IO_ERR | G_IO_HUP | G_IO_NVAL;
+
+    GIOChannel* channel = g_io_channel_unix_new(fd);
+    const unsigned sourceId  = g_io_add_watch
+                               (
+                                channel,
+                                (GIOCondition)condition,
+                                &wx_on_channel_event,
+                                handler
+                               );
+    // it was ref'd by g_io_add_watch() so we can unref it here
+    g_io_channel_unref(channel);
+
+    if ( !sourceId )
+        return NULL;
+
+    wxLogTrace(wxTRACE_EVT_SOURCE,
+               "Adding event loop source for fd=%d with GTK id=%u",
+               fd, sourceId);
+
+
+    return new wxGTKEventLoopSource(sourceId, handler, flags);
+}
+
+wxGTKEventLoopSource::~wxGTKEventLoopSource()
+{
+    wxLogTrace(wxTRACE_EVT_SOURCE,
+               "Removing event loop source with GTK id=%u", m_sourceId);
+
+    g_source_remove(m_sourceId);
+}
+
+#endif // wxUSE_EVENTLOOP_SOURCE
+

 // ----------------------------------------------------------------------------
 // wxEventLoop message processing dispatching
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxEventLoop message processing dispatching
 // ----------------------------------------------------------------------------


@@ -98,7 +180,7 @@ bool wxGUIEventLoop::Pending() const
 
 bool wxGUIEventLoop::Dispatch()
 {
 
 bool wxGUIEventLoop::Dispatch()
 {

-    wxCHECK_MSG( IsRunning(), false, _T("can't call Dispatch() if not running") );
+    wxCHECK_MSG( IsRunning(), false, wxT("can't call Dispatch() if not running") );

 
     // gtk_main_iteration() returns TRUE only if gtk_main_quit() was called
     return !gtk_main_iteration();
 
     // gtk_main_iteration() returns TRUE only if gtk_main_quit() was called
     return !gtk_main_iteration();


@@ -133,13 +215,25 @@ int wxGUIEventLoop::DispatchTimeout(unsigned long timeout)
 // YieldFor
 //-----------------------------------------------------------------------------
 
 // YieldFor
 //-----------------------------------------------------------------------------
 

-static void wxgtk_main_do_event(GdkEvent *event, wxGUIEventLoop* evtloop)
+extern "C" {
+static void wxgtk_main_do_event(GdkEvent* event, void* data)

 {
     // categorize the GDK event according to wxEventCategory.
     // See http://library.gnome.org/devel/gdk/unstable/gdk-Events.html#GdkEventType
     // for more info.
 
 {
     // categorize the GDK event according to wxEventCategory.
     // See http://library.gnome.org/devel/gdk/unstable/gdk-Events.html#GdkEventType
     // for more info.
 

-    wxEventCategory cat = wxEVT_CATEGORY_UNKNOWN;
+    // NOTE: GDK_* constants which were not present in the GDK2.0 can be tested for
+    //       only at compile-time; when running the program (compiled with a recent GDK)
+    //       on a system with an older GDK lib we can be sure there won't be problems
+    //       because event->type will never assume those values corresponding to
+    //       new event types (since new event types are always added in GDK with non
+    //       conflicting values for ABI compatibility).
+
+    // Some events (currently only a single one) may be used for more than one
+    // category, so we need 2 variables. The second one will remain "unknown"
+    // in most cases.
+    wxEventCategory cat = wxEVT_CATEGORY_UNKNOWN,
+                    cat2 = wxEVT_CATEGORY_UNKNOWN;

     switch (event->type)
     {
     case GDK_SELECTION_REQUEST:
     switch (event->type)
     {
     case GDK_SELECTION_REQUEST:


@@ -149,7 +243,6 @@ static void wxgtk_main_do_event(GdkEvent *event, wxGUIEventLoop* evtloop)
         cat = wxEVT_CATEGORY_CLIPBOARD;
         break;
 
         cat = wxEVT_CATEGORY_CLIPBOARD;
         break;
 

-

     case GDK_KEY_PRESS:
     case GDK_KEY_RELEASE:
     case GDK_BUTTON_PRESS:
     case GDK_KEY_PRESS:
     case GDK_KEY_RELEASE:
     case GDK_BUTTON_PRESS:


@@ -161,6 +254,14 @@ static void wxgtk_main_do_event(GdkEvent *event, wxGUIEventLoop* evtloop)
         cat = wxEVT_CATEGORY_USER_INPUT;
         break;
 
         cat = wxEVT_CATEGORY_USER_INPUT;
         break;
 

+    case GDK_PROPERTY_NOTIFY:
+        // This one is special: it can be used for UI purposes but also for
+        // clipboard operations, so allow it in both cases (we probably could
+        // examine the event itself to distinguish between the two cases but
+        // this would be unnecessarily complicated).
+        cat2 = wxEVT_CATEGORY_CLIPBOARD;
+        // Fall through.
+

     case GDK_PROXIMITY_IN:
     case GDK_PROXIMITY_OUT:
 
     case GDK_PROXIMITY_IN:
     case GDK_PROXIMITY_OUT:
 


@@ -168,7 +269,6 @@ static void wxgtk_main_do_event(GdkEvent *event, wxGUIEventLoop* evtloop)
     case GDK_ENTER_NOTIFY:
     case GDK_LEAVE_NOTIFY:
     case GDK_VISIBILITY_NOTIFY:
     case GDK_ENTER_NOTIFY:
     case GDK_LEAVE_NOTIFY:
     case GDK_VISIBILITY_NOTIFY:

-    case GDK_PROPERTY_NOTIFY:

 
     case GDK_FOCUS_CHANGE:
     case GDK_CONFIGURE:
 
     case GDK_FOCUS_CHANGE:
     case GDK_CONFIGURE:


@@ -178,7 +278,9 @@ static void wxgtk_main_do_event(GdkEvent *event, wxGUIEventLoop* evtloop)
     case GDK_DESTROY:
 
     case GDK_EXPOSE:
     case GDK_DESTROY:
 
     case GDK_EXPOSE:

+#ifndef __WXGTK3__

     case GDK_NO_EXPOSE:
     case GDK_NO_EXPOSE:

+#endif

     case GDK_MAP:
     case GDK_UNMAP:
 
     case GDK_MAP:
     case GDK_UNMAP:
 


@@ -188,7 +290,12 @@ static void wxgtk_main_do_event(GdkEvent *event, wxGUIEventLoop* evtloop)
     case GDK_DRAG_STATUS:
     case GDK_DROP_START:
     case GDK_DROP_FINISHED:
     case GDK_DRAG_STATUS:
     case GDK_DROP_START:
     case GDK_DROP_FINISHED:

+#if GTK_CHECK_VERSION(2,8,0)

     case GDK_GRAB_BROKEN:
     case GDK_GRAB_BROKEN:

+#endif
+#if GTK_CHECK_VERSION(2,14,0)
+    case GDK_DAMAGE:
+#endif

         cat = wxEVT_CATEGORY_UI;
         break;
 
         cat = wxEVT_CATEGORY_UI;
         break;
 


@@ -197,12 +304,23 @@ static void wxgtk_main_do_event(GdkEvent *event, wxGUIEventLoop* evtloop)
         break;
     }
 
         break;
     }
 

+    wxGUIEventLoop* evtloop = static_cast<wxGUIEventLoop*>(data);
+

     // is this event allowed now?
     // is this event allowed now?

-    if (evtloop->IsEventAllowedInsideYield(cat))
-        gtk_main_do_event(event);         // process it now
+    if (evtloop->IsEventAllowedInsideYield(cat) ||
+            (cat2 != wxEVT_CATEGORY_UNKNOWN &&
+                evtloop->IsEventAllowedInsideYield(cat2)))
+    {
+        // process it now
+        gtk_main_do_event(event);
+    }

     else if (event->type != GDK_NOTHING)
     else if (event->type != GDK_NOTHING)

+    {
+        // process it later (but make a copy; the caller will free the event
+        // pointer)

         evtloop->StoreGdkEventForLaterProcessing(gdk_event_copy(event));
         evtloop->StoreGdkEventForLaterProcessing(gdk_event_copy(event));

-            // process it later (but make a copy; the caller will free the event pointer)
+    }
+}

 }
 
 bool wxGUIEventLoop::YieldFor(long eventsToProcess)
 }
 
 bool wxGUIEventLoop::YieldFor(long eventsToProcess)


@@ -232,11 +350,16 @@ bool wxGUIEventLoop::YieldFor(long eventsToProcess)
     //       and then call gtk_main_do_event()!
     //       In particular in this way we also process input from sources like
     //       GIOChannels (this is needed for e.g. wxGUIAppTraits::WaitForChild).
     //       and then call gtk_main_do_event()!
     //       In particular in this way we also process input from sources like
     //       GIOChannels (this is needed for e.g. wxGUIAppTraits::WaitForChild).

-    gdk_event_handler_set ((GdkEventFunc)wxgtk_main_do_event, this, NULL);
+    gdk_event_handler_set(wxgtk_main_do_event, this, NULL);

     while (Pending())   // avoid false positives from our idle source
         gtk_main_iteration();
     gdk_event_handler_set ((GdkEventFunc)gtk_main_do_event, NULL, NULL);
 
     while (Pending())   // avoid false positives from our idle source
         gtk_main_iteration();
     gdk_event_handler_set ((GdkEventFunc)gtk_main_do_event, NULL, NULL);
 

+    // Process all pending events too, this is consistent with wxMSW behaviour
+    // and the behaviour of wxGTK itself in the previous versions.
+    if ( wxTheApp )
+        wxTheApp->ProcessPendingEvents();
+

     if (eventsToProcess != wxEVT_CATEGORY_CLIPBOARD)
     {
         // It's necessary to call ProcessIdle() to update the frames sizes which
     if (eventsToProcess != wxEVT_CATEGORY_CLIPBOARD)
     {
         // It's necessary to call ProcessIdle() to update the frames sizes which


@@ -245,7 +368,7 @@ bool wxGUIEventLoop::YieldFor(long eventsToProcess)
         // call ProcessIdle() only once since this is not meant for longish
         // background jobs (controlled by wxIdleEvent::RequestMore() and the
         // return value of Processidle().
         // call ProcessIdle() only once since this is not meant for longish
         // background jobs (controlled by wxIdleEvent::RequestMore() and the
         // return value of Processidle().

-        ProcessIdle();      // ProcessIdle() also calls ProcessPendingEvents()
+        ProcessIdle();

     }
     //else: if we are inside ~wxClipboardSync() and we call ProcessIdle() and
     //      the user app contains an UI update handler which calls wxClipboard::IsSupported,
     }
     //else: if we are inside ~wxClipboardSync() and we call ProcessIdle() and
     //      the user app contains an UI update handler which calls wxClipboard::IsSupported,