path: root/recipes/glib/0015-Implementation-of-Cocoa-event-loop-integration-in-GM.patch

From 4c45757b1687f27e20163a2f3bc560d250dbc123 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= <sebastian@centricular.com>
Date: Fri, 12 Dec 2014 16:40:23 +0100
Subject: [PATCH] Implementation of Cocoa event loop integration in
 GMainContext

---
 configure.ac     |   2 +-
 glib/Makefile.am |   6 +-
 glib/gmain.c     | 990 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 996 insertions(+), 2 deletions(-)

diff --git a/configure.ac b/configure.ac
index 511d404..b3aab01 100644
--- a/configure.ac
+++ b/configure.ac
@@ -239,7 +239,7 @@ AM_CONDITIONAL(OS_COCOA, [test "$glib_have_cocoa" = "yes"])
 
 if test "x$glib_have_cocoa" = "xyes"; then
   AC_DEFINE(HAVE_COCOA, 1, [define to 1 if Cocoa is available])
-  COCOA_LIBS="-Wl,-framework,Foundation"
+  COCOA_LIBS="-Wl,-framework,Foundation -Wl,-framework,AppKit"
   LDFLAGS="$LDFLAGS $COCOA_LIBS"
 fi
 AC_SUBST([COCOA_LIBS])
diff --git a/glib/Makefile.am b/glib/Makefile.am
index 1b9e081..27ae84f 100644
--- a/glib/Makefile.am
+++ b/glib/Makefile.am
@@ -42,6 +42,10 @@ AM_CPPFLAGS = 				\
 	-DGLIB_COMPILATION 		\
 	-DPCRE_STATIC
 
+if OS_COCOA
+AM_CPPFLAGS += -xobjective-c
+endif
+
 AM_CFLAGS = $(GLIB_WARN_CFLAGS)
 
 MIRRORING_TAB_SOURCE = 				\
@@ -348,7 +352,7 @@ pcre_inc =
 endif
 
 libglib_2_0_la_CFLAGS = $(AM_CFLAGS) $(GLIB_HIDDEN_VISIBILITY_CFLAGS)
-libglib_2_0_la_LIBADD = libcharset/libcharset.la $(printf_la) @GIO@ @GSPAWN@ @PLATFORMDEP@ @ICONV_LIBS@ @G_LIBS_EXTRA@ $(pcre_lib) $(G_THREAD_LIBS_EXTRA) $(G_THREAD_LIBS_FOR_GTHREAD)
+libglib_2_0_la_LIBADD = libcharset/libcharset.la $(printf_la) @GIO@ @GSPAWN@ @PLATFORMDEP@ @ICONV_LIBS@ @G_LIBS_EXTRA@ $(pcre_lib) $(G_THREAD_LIBS_EXTRA) $(G_THREAD_LIBS_FOR_GTHREAD) $(COCOA_LIBS)
 libglib_2_0_la_DEPENDENCIES = libcharset/libcharset.la $(printf_la) @GIO@ @GSPAWN@ @PLATFORMDEP@ $(glib_win32_res) $(glib_def)
 
 libglib_2_0_la_LDFLAGS = $(GLIB_LINK_FLAGS) \
diff --git a/glib/gmain.c b/glib/gmain.c
index 30fac70..c25e5bf 100644
--- a/glib/gmain.c
+++ b/glib/gmain.c
@@ -71,6 +71,10 @@
 #include <windows.h>
 #endif /* G_OS_WIN32 */
 
+#ifdef HAVE_COCOA
+#include <Cocoa/Cocoa.h>
+#endif
+
 #ifdef HAVE_MACH_MACH_TIME_H
 #include <mach/mach_time.h>
 #endif
@@ -419,6 +423,90 @@ static GMainContext *glib_worker_context;
 G_LOCK_DEFINE_STATIC (main_loop);
 static GMainContext *default_main_context;
 
+#ifdef HAVE_COCOA
+/* Main context that is acquired on the NS main thread */
+static GMainContext *cocoa_main_context;
+
+/******* State for run loop iteration *******/
+
+/* Count of number of times we've gotten an "Entry" notification for
+ * our run loop observer.
+ */
+static int cocoa_current_loop_level = 0;
+
+/* Run loop level at which we acquired ownership of the GLib main
+ * loop. See note in run_loop_entry(). -1 means that we don’t have
+ * ownership
+ */ 
+static int cocoa_acquired_loop_level = -1;
+
+/* Between run_loop_before_waiting() and run_loop_after_waiting();
+ * whether we we need to call select_thread_collect_poll()
+ */
+static gboolean cocoa_run_loop_polling_async = FALSE;
+
+/* Between run_loop_before_waiting() and run_loop_after_waiting();
+ * max_prioritiy to pass to g_main_loop_check()
+ */
+static gint cocoa_run_loop_max_priority;
+
+/* Timer that we've added to wake up the run loop when a GLib timeout
+ */
+static CFRunLoopTimerRef cocoa_run_loop_timer = NULL;
+
+/* These are the file descriptors that are we are polling out of
+ * the run loop. (We keep the array around and reuse it to avoid
+ * constant allocations.)
+ */
+#define RUN_LOOP_POLLFDS_INITIAL_SIZE 16
+static GPollFD *cocoa_run_loop_pollfds;
+static guint cocoa_run_loop_pollfds_size; /* Allocated size of the array */
+static guint cocoa_run_loop_n_pollfds;    /* Number of file descriptors in the array */
+
+/******* Other global variables *******/
+
+/* The default poll function for GLib; we replace this with our own
+ * Cocoa-aware version and then call the old version to do actual
+ * file descriptor polling. There’s no actual need to chain to the
+ * old one; we could reimplement the same functionality from scratch,
+ * but since the default implementation does the right thing, why
+ * bother.
+ */
+static GPollFunc cocoa_old_poll_func;
+
+/* Reference to the run loop of the main thread. (There is a unique
+ * CFRunLoop per thread.)
+ */
+static CFRunLoopRef cocoa_main_thread_run_loop;
+
+/* Reference to our run loop observer */
+static CFRunLoopObserverRef cocoa_observer;
+
+/* Normally the Cocoa main loop maintains an NSAutoReleasePool and frees
+ * it on every iteration. Since we are replacing the main loop we have
+ * to provide this functionality ourself. We free and replace the
+ * auto-release pool in our sources prepare() function.
+ */
+static NSAutoreleasePool *cocoa_autorelease_pool;
+
+/* Flag when we've called nextEventMatchingMask ourself; this triggers
+ * a run loop iteration, so we need to detect that and avoid triggering
+ * our "run the GLib main looop while the run loop is active machinery.
+ */
+static gint cocoa_getting_events = 0;
+
+static gint cocoa_poll_func (GPollFD *fds, guint nfds, gint timeout);
+static void
+cocoa_run_loop_observer_callback (CFRunLoopObserverRef observer,
+			    CFRunLoopActivity    activity,
+			    void                *info);
+
+/* FIXME: Random number that hopefully is not used by any application on
+ * top of GLib
+ */
+#define GMAIN_COCOA_EVENT_SUBTYPE_EVENTLOOP ((short)31722)
+#endif /* HAVE_COCOA */
+
 #ifndef G_OS_WIN32
 
 
@@ -3174,6 +3262,36 @@ g_main_context_acquire (GMainContext *context)
     {
       context->owner = self;
       g_assert (context->owner_count == 0);
+#ifdef HAVE_COCOA
+      /* FIXME: Also for other poll funcs? GDK? */
+      if ([NSThread isMainThread] && context->poll_func == g_poll) {
+        if (g_atomic_pointer_compare_and_exchange (&cocoa_main_context, NULL, context))
+          {
+#ifdef G_MAIN_POLL_DEBUG
+            g_print("%p became new cocoa main context\n", context);
+#endif
+
+            /* Make sure the NSApplication is initialized */
+            [NSApplication sharedApplication];
+
+            cocoa_old_poll_func = context->poll_func;
+            context->poll_func = cocoa_poll_func;
+
+            /* Hook into the the CFRunLoop for the main thread */
+            cocoa_main_thread_run_loop = CFRunLoopGetCurrent ();
+            cocoa_observer = CFRunLoopObserverCreate (NULL, /* default allocator */
+                                                kCFRunLoopAllActivities,
+                                                true, /* repeats: not one-shot */
+                                                0, /* order (priority) */
+                                                cocoa_run_loop_observer_callback,
+                                                NULL);
+            CFRunLoopAddObserver (cocoa_main_thread_run_loop, cocoa_observer, kCFRunLoopCommonModes);
+
+            /* Initialize our autorelease pool */
+            cocoa_autorelease_pool = [[NSAutoreleasePool alloc] init];
+          }
+      }
+#endif
     }
 
   if (context->owner == self)
@@ -3223,6 +3341,25 @@ g_main_context_release (GMainContext *context)
 	  if (!loop_internal_waiter)
 	    g_mutex_unlock (waiter->mutex);
 	}
+
+#ifdef HAVE_COCOA
+      if (g_atomic_pointer_compare_and_exchange (&cocoa_main_context, context, NULL))
+        {
+#ifdef G_MAIN_POLL_DEBUG
+          g_print ("%p stopped being the cocoa default main context\n", context);
+#endif
+          context->poll_func = cocoa_old_poll_func;
+          cocoa_old_poll_func = NULL;
+
+          CFRunLoopRemoveObserver (cocoa_main_thread_run_loop, cocoa_observer, kCFRunLoopCommonModes);
+          CFRelease (cocoa_observer);
+          cocoa_observer = NULL;
+          cocoa_main_thread_run_loop = NULL;
+
+          [cocoa_autorelease_pool release];
+          cocoa_autorelease_pool = NULL;
+        }
+#endif
     }
 
   UNLOCK_CONTEXT (context); 
@@ -5622,3 +5759,856 @@ g_get_worker_context (void)
 
   return glib_worker_context;
 }
+
+#ifdef HAVE_COCOA
+
+/* 
+ * Here follows the integration between the GLib main loop and
+ * the native system of the Core Foundation run loop and Cocoa event
+ * handling. There are basically two different cases that we need to
+ * handle: either the GLib main loop is in control (the application
+ * has called gtk_main(), or is otherwise iterating the main loop), or
+ * CFRunLoop is in control (we are in a modal operation such as window
+ * resizing or drag-and-drop.)
+ *
+ * When the GLib main loop is in control we integrate in native event
+ * handling in two ways: first we add a GSource that handles checking
+ * whether there are native events available, translating native events
+ * to GDK events, and dispatching GDK events. Second we replace the
+ * "poll function" of the GLib main loop with our own version that knows
+ * how to wait for both the file descriptors and timeouts that GLib is
+ * interested in and also for incoming native events.
+ *
+ * When CFRunLoop is in control, we integrate in GLib main loop handling
+ * by adding a "run loop observer" that gives us notification at various
+ * points in the run loop cycle. We map these points onto the corresponding
+ * stages of the GLib main loop (prepare, check, dispatch), and make the
+ * appropriate calls into GLib.
+ *
+ * Both cases share a single problem: the OS X API’s don’t allow us to
+ * wait simultaneously for file descriptors and for events. So when we
+ * need to do a blocking wait that includes file descriptor activity, we
+ * push the actual work of calling select() to a helper thread (the
+ * "select thread") and wait for native events in the main thread.
+ *
+ * The main known limitation of this code is that if a callback is triggered
+ * via the OS X run loop while we are "polling" (in either case described
+ * above), iteration of the GLib main loop is not possible from within
+ * that callback. If the programmer tries to do so explicitly, then they
+ * will get a warning from GLib "main loop already active in another thread".
+ */
+
+/************************************************************
+ *********              Select Thread               *********
+ ************************************************************/
+
+/* The states in our state machine, see comments in select_thread_func()
+ * for descriptiions of each state
+ */
+typedef enum {
+  COCOA_BEFORE_START,
+  COCOA_WAITING,
+  COCOA_POLLING_QUEUED,
+  COCOA_POLLING_RESTART,
+  COCOA_POLLING_DESCRIPTORS,
+} CocoaSelectThreadState;
+
+static const char *const cocoa_state_names[]  = {
+  "BEFORE_START",
+  "WAITING",
+  "POLLING_QUEUED",
+  "POLLING_RESTART",
+  "POLLING_DESCRIPTORS"
+};
+
+static CocoaSelectThreadState cocoa_select_thread_state = COCOA_BEFORE_START;
+
+static GThread *cocoa_select_thread;
+static GMutex cocoa_select_thread_mutex;
+static GCond cocoa_select_thread_cond;
+
+#define COCOA_SELECT_THREAD_LOCK() g_mutex_lock (&cocoa_select_thread_mutex)
+#define COCOA_SELECT_THREAD_UNLOCK() g_mutex_unlock (&cocoa_select_thread_mutex)
+#define COCOA_SELECT_THREAD_SIGNAL() g_cond_signal (&cocoa_select_thread_cond)
+#define COCOA_SELECT_THREAD_WAIT() g_cond_wait (&cocoa_select_thread_cond, &cocoa_select_thread_mutex)
+
+/* These are the file descriptors that the select thread is currently
+ * polling.
+ */
+static GPollFD *cocoa_current_pollfds;
+static guint cocoa_current_n_pollfds;
+
+/* These are the file descriptors that the select thread should pick
+ * up and start polling when it has a chance.
+ */
+static GPollFD *cocoa_next_pollfds;
+static guint cocoa_next_n_pollfds;
+
+/* Pipe used to wake up the select thread */
+static gint cocoa_select_thread_wakeup_pipe[2];
+
+/* Run loop source used to wake up the main thread */
+static CFRunLoopSourceRef cocoa_select_main_thread_source;
+
+static void
+cocoa_select_thread_set_state (CocoaSelectThreadState new_state)
+{
+  gboolean old_state;
+
+  if (cocoa_select_thread_state == new_state)
+    return;
+
+#ifdef G_MAIN_POLL_DEBUG
+  g_print ("EventLoop: Select thread state: %s => %s\n", cocoa_state_names[cocoa_select_thread_state], cocoa_state_names[new_state]);
+#endif
+
+  old_state = cocoa_select_thread_state;
+  cocoa_select_thread_state = new_state;
+  if (old_state == COCOA_WAITING && new_state != COCOA_WAITING)
+    COCOA_SELECT_THREAD_SIGNAL ();
+}
+
+static void
+cocoa_signal_main_thread (void)
+{
+#ifdef G_MAIN_POLL_DEBUG
+  g_print ("EventLoop: Waking up main thread\n");
+#endif
+
+  /* If we are in nextEventMatchingMask, then we need to make sure an
+   * event gets queued, otherwise it's enough to simply wake up the
+   * main thread run loop
+   */
+  if (!cocoa_run_loop_polling_async)
+    CFRunLoopSourceSignal (cocoa_select_main_thread_source);
+
+  /* Don't check for CFRunLoopIsWaiting() here because it causes a
+   * race condition (the loop could go into waiting state right after
+   * we checked).
+   */
+  CFRunLoopWakeUp (cocoa_main_thread_run_loop);
+}
+
+static void *
+cocoa_select_thread_func (void *arg)
+{
+  char c;
+  
+  COCOA_SELECT_THREAD_LOCK ();
+
+  while (TRUE)
+    {
+      switch (cocoa_select_thread_state)
+	{
+	case COCOA_BEFORE_START:
+	  /* The select thread has not been started yet
+	   */
+	  g_assert_not_reached ();
+	  
+	case COCOA_WAITING:
+	  /* Waiting for a set of file descriptors to be submitted by the main thread
+	   *
+	   *  => POLLING_QUEUED: main thread thread submits a set of file descriptors
+	   */ 
+	  COCOA_SELECT_THREAD_WAIT ();
+	  break;
+	  
+	case COCOA_POLLING_QUEUED:
+	  /* Waiting for a set of file descriptors to be submitted by the main thread
+	   *
+	   *  => POLLING_DESCRIPTORS: select thread picks up the file descriptors to begin polling
+	   */ 
+	  g_free (cocoa_current_pollfds);
+	  
+	  cocoa_current_pollfds = cocoa_next_pollfds;
+	  cocoa_current_n_pollfds = cocoa_next_n_pollfds;
+
+	  cocoa_next_pollfds = NULL;
+	  cocoa_next_n_pollfds = 0;
+
+	  cocoa_select_thread_set_state (COCOA_POLLING_DESCRIPTORS);
+	  break;
+	  
+	case COCOA_POLLING_RESTART:
+	  /* Select thread is currently polling a set of file descriptors, main thread has
+	   * began a new iteration with the same set of file descriptors. We don't want to
+	   * wake the select thread up and wait for it to restart immediately, but to avoid
+	   * a race (described below in select_thread_start_polling()) we need to recheck after
+	   * polling completes.
+	   *
+	   * => POLLING_DESCRIPTORS: select completes, main thread rechecks by polling again
+	   * => POLLING_QUEUED: main thread submits a new set of file descriptors to be polled
+	   */
+	  cocoa_select_thread_set_state (COCOA_POLLING_DESCRIPTORS);
+	  break;
+
+	case COCOA_POLLING_DESCRIPTORS:
+	  /* In the process of polling the file descriptors
+	   *
+	   *  => WAITING: polling completes when a file descriptor becomes active
+	   *  => POLLING_QUEUED: main thread submits a new set of file descriptors to be polled
+	   *  => POLLING_RESTART: main thread begins a new iteration with the same set file descriptors
+	   */ 
+	  COCOA_SELECT_THREAD_UNLOCK ();
+	  cocoa_old_poll_func (cocoa_current_pollfds, cocoa_current_n_pollfds, -1);
+	  COCOA_SELECT_THREAD_LOCK ();
+
+	  read (cocoa_select_thread_wakeup_pipe[0], &c, 1);
+
+	  if (cocoa_select_thread_state == COCOA_POLLING_DESCRIPTORS)
+	    {
+	      cocoa_signal_main_thread ();
+	      cocoa_select_thread_set_state (COCOA_WAITING);
+	    }
+	  break;
+	}
+    }
+}
+
+static void 
+cocoa_got_fd_activity (void *info)
+{
+  NSEvent *event;
+
+  /* Post a message so we'll break out of the message loop */
+  event = [NSEvent otherEventWithType: NSApplicationDefined
+	                     location: NSZeroPoint
+	                modifierFlags: 0
+	                    timestamp: 0
+	                 windowNumber: 0
+	                      context: nil
+                              subtype: GMAIN_COCOA_EVENT_SUBTYPE_EVENTLOOP
+	                        data1: 0 
+	                        data2: 0];
+
+  [NSApp postEvent:event atStart:YES];
+}
+
+static void
+cocoa_select_thread_start (void)
+{
+  g_return_if_fail (cocoa_select_thread_state == COCOA_BEFORE_START);
+
+  pipe (cocoa_select_thread_wakeup_pipe);
+  fcntl (cocoa_select_thread_wakeup_pipe[0], F_SETFL, O_NONBLOCK);
+
+  CFRunLoopSourceContext source_context = {0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, cocoa_got_fd_activity };
+  cocoa_select_main_thread_source = CFRunLoopSourceCreate (NULL, 0, &source_context);
+  
+  CFRunLoopAddSource (cocoa_main_thread_run_loop, cocoa_select_main_thread_source, kCFRunLoopCommonModes);
+
+  cocoa_select_thread_state = COCOA_WAITING;
+  
+  while (TRUE)
+    {
+      if ((cocoa_select_thread = g_thread_new ("CocoaSelectThread", cocoa_select_thread_func, NULL)))
+	  break;
+
+      g_warning ("Failed to create select thread, sleeping and trying again");
+      sleep (1);
+    }
+}
+
+#ifdef G_ENABLE_DEBUG
+#ifdef G_MAIN_POLL_DEBUG
+static void
+cocoa_dump_poll_result (GPollFD *ufds,
+		  guint    nfds)
+{
+  gint i;
+
+  for (i = 0; i < nfds; i++)
+    {
+      if (ufds[i].fd >= 0 && ufds[i].revents)
+	{
+	  g_print (" %d:", ufds[i].fd);
+	  if (ufds[i].revents & G_IO_IN)
+	    g_print (" in");
+	  if (ufds[i].revents & G_IO_OUT)
+	    g_print (" out");
+	  if (ufds[i].revents & G_IO_PRI)
+	    g_print (" pri");
+	  g_print ("\n");
+	}
+    }
+}
+#endif
+#endif
+
+static gboolean
+cocoa_pollfds_equal (GPollFD *old_pollfds,
+	       guint    old_n_pollfds,
+	       GPollFD *new_pollfds,
+	       guint    new_n_pollfds)
+{
+  gint i;
+  
+  if (old_n_pollfds != new_n_pollfds)
+    return FALSE;
+
+  for (i = 0; i < old_n_pollfds; i++)
+    {
+      if (old_pollfds[i].fd != new_pollfds[i].fd ||
+	  old_pollfds[i].events != new_pollfds[i].events)
+	return FALSE;
+    }
+
+  return TRUE;
+}
+
+/* Begins a polling operation with the specified GPollFD array; the 
+ * timeout is used only to tell if the polling operation is blocking
+ * or non-blocking.
+ *
+ * Returns:
+ *  -1: No file descriptors ready, began asynchronous poll
+ *   0: No file descriptors ready, asynchronous poll not needed
+ * > 0: Number of file descriptors ready
+ */
+static gint
+cocoa_select_thread_start_poll (GPollFD *ufds,
+                                guint    nfds,
+                                gint     timeout)
+{
+  gint n_ready;
+  gboolean have_new_pollfds = FALSE;
+  gint poll_fd_index = -1;
+  gint i;
+
+  for (i = 0; i < nfds; i++)
+    if (ufds[i].fd == -1)
+      {
+	poll_fd_index = i;
+	break;
+      }
+  
+  if (nfds == 0 ||
+      (nfds == 1 && poll_fd_index >= 0))
+    {
+#ifdef G_MAIN_POLL_DEBUG
+      g_print ("EventLoop: Nothing to poll\n");
+#endif
+      return 0;
+    }
+
+  /* If we went immediately to an async poll, then we might decide to
+   * dispatch idle functions when higher priority file descriptor sources
+   * are ready to be dispatched. So we always need to first check
+   * check synchronously with a timeout of zero, and only when no
+   * sources are immediately ready, go to the asynchronous poll.
+   *
+   * Of course, if the timeout passed in is 0, then the synchronous
+   * check is sufficient and we never need to do the asynchronous poll.
+   */
+  n_ready = cocoa_old_poll_func (ufds, nfds, 0);
+  if (n_ready > 0 || timeout == 0)
+    {
+#ifdef G_ENABLE_DEBUG
+#ifdef G_MAIN_POLL_DEBUG
+      if (n_ready > 0)
+	{
+	  g_print ("EventLoop: Found ready file descriptors before waiting\n");
+	  cocoa_dump_poll_result (ufds, nfds);
+	}
+#endif
+#endif
+  
+      return n_ready;
+    }
+  
+  COCOA_SELECT_THREAD_LOCK ();
+
+  if (cocoa_select_thread_state == COCOA_BEFORE_START)
+    {
+      cocoa_select_thread_start ();
+    }
+  
+  if (cocoa_select_thread_state == COCOA_POLLING_QUEUED)
+    {
+      /* If the select thread hasn't picked up the set of file descriptors yet
+       * then we can simply replace an old stale set with a new set.
+       */
+      if (!cocoa_pollfds_equal (ufds, nfds, cocoa_next_pollfds, cocoa_next_n_pollfds - 1))
+	{
+	  g_free (cocoa_next_pollfds);
+	  cocoa_next_pollfds = NULL;
+	  cocoa_next_n_pollfds = 0;
+	  
+	  have_new_pollfds = TRUE;
+	}
+    }
+  else if (cocoa_select_thread_state == COCOA_POLLING_RESTART || cocoa_select_thread_state == COCOA_POLLING_DESCRIPTORS)
+    {
+      /* If we are already in the process of polling the right set of file descriptors,
+       * there's no need for us to immediately force the select thread to stop polling
+       * and then restart again. And avoiding doing so increases the efficiency considerably
+       * in the common case where we have a set of basically inactive file descriptors that
+       * stay unchanged present as we process many events.
+       *
+       * However, we have to be careful that we don't hit the following race condition
+       *  Select Thread              Main Thread
+       *  -----------------          ---------------
+       *  Polling Completes
+       *                             Reads data or otherwise changes file descriptor state
+       *                             Checks if polling is current
+       *                             Does nothing (*)
+       *                             Releases lock
+       *  Acquires lock
+       *  Marks polling as complete
+       *  Wakes main thread
+       *                             Receives old stale file descriptor state
+       * 
+       * To avoid this, when the new set of poll descriptors is the same as the current
+       * one, we transition to the POLLING_RESTART stage at the point marked (*). When
+       * the select thread wakes up from the poll because a file descriptor is active, if
+       * the state is POLLING_RESTART it immediately begins polling same the file descriptor
+       * set again. This normally will just return the same set of active file descriptors
+       * as the first time, but in sequence described above will properly update the
+       * file descriptor state.
+       *
+       * Special case: this RESTART logic is not needed if the only FD is the internal GLib
+       * "wakeup pipe" that is presented when threads are initialized.
+       *
+       * P.S.: The harm in the above sequence is mostly that sources can be signalled
+       *   as ready when they are no longer ready. This may prompt a blocking read
+       *   from a file descriptor that hangs.
+       */
+      if (!cocoa_pollfds_equal (ufds, nfds, cocoa_current_pollfds, cocoa_current_n_pollfds - 1))
+	have_new_pollfds = TRUE;
+      else
+	{
+	  if (!((nfds == 1 && poll_fd_index < 0 && g_thread_supported ()) ||
+		(nfds == 2 && poll_fd_index >= 0 && g_thread_supported ())))
+	    cocoa_select_thread_set_state (COCOA_POLLING_RESTART);
+	}
+    }
+  else
+    have_new_pollfds = TRUE;
+
+  if (have_new_pollfds)
+    {
+#ifdef G_MAIN_POLL_DEBUG
+      g_print ("EventLoop: Submitting a new set of file descriptor to the select thread\n");
+#endif
+      
+      g_assert (cocoa_next_pollfds == NULL);
+      
+      cocoa_next_n_pollfds = nfds + 1;
+      cocoa_next_pollfds = g_new (GPollFD, nfds + 1);
+      memcpy (cocoa_next_pollfds, ufds, nfds * sizeof (GPollFD));
+  
+      cocoa_next_pollfds[nfds].fd = cocoa_select_thread_wakeup_pipe[0];
+      cocoa_next_pollfds[nfds].events = G_IO_IN;
+  
+      if (cocoa_select_thread_state != COCOA_POLLING_QUEUED && cocoa_select_thread_state != COCOA_WAITING)
+	{
+	  if (cocoa_select_thread_wakeup_pipe[1])
+	    {
+	      char c = 'A';
+	      write (cocoa_select_thread_wakeup_pipe[1], &c, 1);
+	    }
+	}
+      
+      cocoa_select_thread_set_state (COCOA_POLLING_QUEUED);
+    }
+  
+  COCOA_SELECT_THREAD_UNLOCK ();
+
+  return -1;
+}
+
+/* End an asynchronous polling operation started with
+ * select_thread_collect_poll(). This must be called if and only if
+ * select_thread_start_poll() return -1. The GPollFD array passed
+ * in must be identical to the one passed to select_thread_start_poll().
+ *
+ * The results of the poll are written into the GPollFD array passed in.
+ *
+ * Returns: number of file descriptors ready
+ */
+static int
+cocoa_select_thread_collect_poll (GPollFD *ufds, guint nfds)
+{
+  gint i;
+  gint n_ready = 0;
+  
+  COCOA_SELECT_THREAD_LOCK ();
+
+  if (cocoa_select_thread_state == COCOA_WAITING) /* The poll completed */
+    {
+      for (i = 0; i < nfds; i++)
+	{
+	  if (ufds[i].fd == -1)
+	    continue;
+	  
+	  g_assert (ufds[i].fd == cocoa_current_pollfds[i].fd);
+	  g_assert (ufds[i].events == cocoa_current_pollfds[i].events);
+
+	  if (cocoa_current_pollfds[i].revents)
+	    {
+	      ufds[i].revents = cocoa_current_pollfds[i].revents;
+	      n_ready++;
+	    }
+	}
+
+#ifdef G_ENABLE_DEBUG
+#ifdef G_MAIN_POLL_DEBUG
+      g_print ("EventLoop: Found ready file descriptors after waiting\n");
+      cocoa_dump_poll_result (ufds, nfds);
+#endif
+#endif
+    }
+
+  COCOA_SELECT_THREAD_UNLOCK ();
+
+  return n_ready;
+}
+
+/************************************************************
+ *********             Our Poll Function            *********
+ ************************************************************/
+
+static gint
+cocoa_poll_func (GPollFD *ufds,
+	   guint    nfds,
+	   gint     timeout_)
+{
+  NSEvent *event;
+  NSDate *limit_date;
+  gint n_ready;
+
+  static GPollFD *last_ufds;
+
+  last_ufds = ufds;
+
+  n_ready = cocoa_select_thread_start_poll (ufds, nfds, timeout_);
+  if (n_ready > 0)
+    timeout_ = 0;
+
+  if (timeout_ == -1)
+    limit_date = [NSDate distantFuture];
+  else if (timeout_ == 0)
+    limit_date = [NSDate distantPast];
+  else
+    limit_date = [NSDate dateWithTimeIntervalSinceNow:timeout_/1000.0];
+
+  cocoa_getting_events++;
+  event = [NSApp nextEventMatchingMask: NSAnyEventMask
+	                     untilDate: limit_date
+	                        inMode: NSDefaultRunLoopMode
+                               dequeue: YES];
+  cocoa_getting_events--;
+
+  /* We check if last_ufds did not change since the time this function was
+   * called. It is possible that a recursive main loop (and thus recursive
+   * invocation of this poll function) is triggered while in
+   * nextEventMatchingMask:. If during that time new fds are added,
+   * the cached fds array might be replaced in g_main_context_iterate().
+   * So, we should avoid accessing the old fd array (still pointed at by
+   * ufds) here in that case, since it might have been freed. We avoid this
+   * by not calling the collect stage.
+   */
+  if (last_ufds == ufds && n_ready < 0)
+    n_ready = cocoa_select_thread_collect_poll (ufds, nfds);
+
+  if (event &&
+      [event type] == NSApplicationDefined &&
+      [event subtype] == GMAIN_COCOA_EVENT_SUBTYPE_EVENTLOOP)
+    {
+      /* Just used to wake us up; if an event and a FD arrived at the same
+       * time; could have come from a previous iteration in some cases,
+       * but the spurious wake up is harmless if a little inefficient.
+       */
+      event = NULL;
+    }
+
+  if (event)
+    {
+      /* TODO: Allow the application to intercept events before sending them.
+       * GDK needs this for translating Cocoa events into GDK events
+       */
+#ifdef G_MAIN_POLL_DEBUG
+      g_print ("sending event\n");
+#endif
+      [NSApp sendEvent:event];
+    }
+
+  /* The prepare stage is the stage before the main loop starts polling
+   * and dispatching events. The autorelease poll is drained here for
+   * the preceding main loop iteration or, in case of the first iteration,
+   * for the operations carried out between event loop initialization and
+   * this first iteration.
+   *
+   * The autorelease poll must only be drained when the following conditions
+   * apply:
+   *  - We are at the base CFRunLoop level (indicated by current_loop_level),
+   *  - We are at the base g_main_loop level (indicated by
+   *    g_main_depth())
+   *  - We are at the base poll_func level (indicated by getting events).
+   *
+   * Messing with the autorelease pool at any level of nesting can cause access
+   * to deallocated memory because autorelease_pool is static and releasing a
+   * pool will cause all pools allocated inside of it to be released as well.
+   */
+  if (cocoa_current_loop_level == 0 && g_main_depth() == 0 && cocoa_getting_events == 0)
+    {
+      if (cocoa_autorelease_pool)
+        [cocoa_autorelease_pool release];
+
+      cocoa_autorelease_pool = [[NSAutoreleasePool alloc] init];
+    }
+
+  return n_ready;
+}
+
+/************************************************************
+ *********  Running the main loop out of CFRunLoop  *********
+ ************************************************************/
+
+/* Wrapper around g_main_context_query() that handles reallocating
+ * run_loop_pollfds up to the proper size
+ */
+static gint
+cocoa_query_main_context (GMainContext *context,
+		    int           max_priority,
+		    int          *timeout)
+{
+  gint nfds;
+  
+  if (!cocoa_run_loop_pollfds)
+    {
+      cocoa_run_loop_pollfds_size = RUN_LOOP_POLLFDS_INITIAL_SIZE;
+      cocoa_run_loop_pollfds = g_new (GPollFD, cocoa_run_loop_pollfds_size);
+    }
+
+  while ((nfds = g_main_context_query (context, max_priority, timeout,
+				       cocoa_run_loop_pollfds,
+				       cocoa_run_loop_pollfds_size)) > cocoa_run_loop_pollfds_size)
+    {
+      g_free (cocoa_run_loop_pollfds);
+      cocoa_run_loop_pollfds_size = nfds;
+      cocoa_run_loop_pollfds = g_new (GPollFD, nfds);
+    }
+
+  return nfds;
+}
+
+static void
+cocoa_run_loop_entry (void)
+{
+  if (cocoa_acquired_loop_level == -1)
+    {
+      if (g_main_context_acquire (cocoa_main_context))
+	{
+#ifdef G_MAIN_POLL_DEBUG
+	  g_print ("EventLoop: Beginning tracking run loop activity\n");
+#endif
+	  cocoa_acquired_loop_level = cocoa_current_loop_level;
+	}
+      else
+	{
+	  /* If we fail to acquire the main context, that means someone is iterating
+	   * the main context in a different thread; we simply wait until this loop
+	   * exits and then try again at next entry. In general, iterating the loop
+	   * from a different thread is rare: it is only possible when GDK threading
+	   * is initialized and is not frequently used even then. So, we hope that
+	   * having GLib main loop iteration blocked in the combination of that and
+	   * a native modal operation is a minimal problem. We could imagine using a
+	   * thread that does g_main_context_wait() and then wakes us back up, but
+	   * the gain doesn't seem worth the complexity.
+	   */
+#ifdef G_MAIN_POLL_DEBUG
+	  g_print ("EventLoop: Can't acquire main loop; skipping tracking run loop activity\n");
+#endif
+	}
+    }
+}
+
+static void
+cocoa_run_loop_before_timers (void)
+{
+}
+
+static void
+cocoa_run_loop_before_sources (void)
+{
+  GMainContext *context = cocoa_main_context;
+  gint max_priority;
+  gint nfds;
+
+  /* Before we let the CFRunLoop process sources, we want to check if there
+   * are any pending GLib main loop sources more urgent than
+   * G_PRIORITY_DEFAULT that need to be dispatched. (We consider all activity
+   * from the CFRunLoop to have a priority of G_PRIORITY_DEFAULT.) If no
+   * sources are processed by the CFRunLoop, then processing will continue
+   * on to the BeforeWaiting stage where we check for lower priority sources.
+   */
+
+  g_main_context_prepare (context, &max_priority); 
+  max_priority = MIN (max_priority, G_PRIORITY_DEFAULT);
+
+  /* We ignore the timeout that query_main_context () returns since we'll
+   * always query again before waiting.
+   */
+  nfds = cocoa_query_main_context (context, max_priority, NULL);
+
+  if (nfds)
+    cocoa_old_poll_func (cocoa_run_loop_pollfds, nfds, 0);
+
+  if (g_main_context_check (context, max_priority, cocoa_run_loop_pollfds, nfds))
+    {
+#ifdef G_MAIN_POLL_DEBUG
+      g_print ("EventLoop: Dispatching high priority sources\n");
+#endif
+      g_main_context_dispatch (context);
+    }
+}
+
+static void
+cocoa_dummy_timer_callback (CFRunLoopTimerRef  timer,
+		      void              *info)
+{
+  /* Nothing; won't normally even be called */
+}
+
+static void
+cocoa_run_loop_before_waiting (void)
+{
+  GMainContext *context = cocoa_main_context;
+  gint timeout;
+  gint n_ready;
+
+  /* At this point, the CFRunLoop is ready to wait. We start a GMain loop
+   * iteration by calling the check() and query() stages. We start a
+   * poll, and if it doesn't complete immediately we let the run loop
+   * go ahead and sleep. Before doing that, if there was a timeout from
+   * GLib, we set up a CFRunLoopTimer to wake us up.
+   */
+  
+  g_main_context_prepare (context, &cocoa_run_loop_max_priority); 
+  
+  cocoa_run_loop_n_pollfds = cocoa_query_main_context (context, cocoa_run_loop_max_priority, &timeout);
+
+  n_ready = cocoa_select_thread_start_poll (cocoa_run_loop_pollfds, cocoa_run_loop_n_pollfds, timeout);
+
+  if (n_ready > 0 || timeout == 0)
+    {
+      /* We have stuff to do, no sleeping allowed! */
+      CFRunLoopWakeUp (cocoa_main_thread_run_loop);
+    }
+  else if (timeout > 0)
+    {
+      /* We need to get the run loop to break out of its wait when our timeout
+       * expires. We do this by adding a dummy timer that we'll remove immediately
+       * after the wait wakes up.
+       */
+#ifdef G_MAIN_POLL_DEBUG
+      g_print ("EventLoop: Adding timer to wake us up in %d milliseconds\n", timeout);
+#endif
+      
+      cocoa_run_loop_timer = CFRunLoopTimerCreate (NULL, /* allocator */
+					     CFAbsoluteTimeGetCurrent () + timeout / 1000.,
+					     0, /* interval (0=does not repeat) */
+					     0, /* flags */
+					     0, /* order (priority) */
+					     cocoa_dummy_timer_callback,
+					     NULL);
+
+      CFRunLoopAddTimer (cocoa_main_thread_run_loop, cocoa_run_loop_timer, kCFRunLoopCommonModes);
+    }
+  
+  cocoa_run_loop_polling_async = n_ready < 0;
+}
+
+static void
+cocoa_run_loop_after_waiting (void)
+{
+  GMainContext *context = cocoa_main_context;
+
+  /* After sleeping, we finish of the GMain loop iteratin started in before_waiting()
+   * by doing the check() and dispatch() stages.
+   */
+
+  if (cocoa_run_loop_timer)
+    {
+      CFRunLoopRemoveTimer (cocoa_main_thread_run_loop, cocoa_run_loop_timer, kCFRunLoopCommonModes);
+      CFRelease (cocoa_run_loop_timer);
+      cocoa_run_loop_timer = NULL;
+    }
+  
+  if (cocoa_run_loop_polling_async)
+    {
+      cocoa_select_thread_collect_poll (cocoa_run_loop_pollfds, cocoa_run_loop_n_pollfds);
+      cocoa_run_loop_polling_async = FALSE;
+    }
+  
+  if (g_main_context_check (context, cocoa_run_loop_max_priority, cocoa_run_loop_pollfds, cocoa_run_loop_n_pollfds))
+    {
+#ifdef G_MAIN_POLL_DEBUG
+      g_print ("EventLoop: Dispatching after waiting\n");
+#endif
+      g_main_context_dispatch (context);
+    }
+}
+
+static void
+cocoa_run_loop_exit (void)
+{
+  /* + 1 because we decrement current_loop_level separately in observer_callback() */
+  if ((cocoa_current_loop_level + 1) == cocoa_acquired_loop_level)
+    {
+      g_main_context_release (cocoa_main_context);
+      cocoa_acquired_loop_level = -1;
+#ifdef G_MAIN_POLL_DEBUG
+      g_print ("EventLoop: Ended tracking run loop activity\n");
+#endif
+    }
+}
+
+static void
+cocoa_run_loop_observer_callback (CFRunLoopObserverRef observer,
+			    CFRunLoopActivity    activity,
+			    void                *info)
+{
+  switch (activity)
+    {
+    case kCFRunLoopEntry:
+      cocoa_current_loop_level++;
+      break;
+    case kCFRunLoopExit:
+      g_return_if_fail (cocoa_current_loop_level > 0);
+      cocoa_current_loop_level--;
+      break;
+    default:
+      break;
+    }
+
+  if (cocoa_getting_events > 0) /* Activity we triggered */
+    return;
+
+  switch (activity)
+    {
+    case kCFRunLoopEntry:
+      cocoa_run_loop_entry ();
+      break;
+    case kCFRunLoopBeforeTimers:
+      cocoa_run_loop_before_timers ();
+      break;
+    case kCFRunLoopBeforeSources:
+      cocoa_run_loop_before_sources ();
+      break;
+    case kCFRunLoopBeforeWaiting:
+      cocoa_run_loop_before_waiting ();
+      break;
+    case kCFRunLoopAfterWaiting:
+      cocoa_run_loop_after_waiting ();
+      break;
+    case kCFRunLoopExit:
+      cocoa_run_loop_exit ();
+      break;
+    default:
+      break;
+    }
+}
+
+#endif
-- 
1.9.3 (Apple Git-50)