Use a select wrapper around the GLib event loop, thus taking into account GLib

timeouts and event sources.  This simplifies Gtk+-code a lot, and is needed
for handling GConf death/restart.

* xterm.c: #include xgselect.h.
(x_initialize): Call xgselect_initialize.

* xsettings.c (something_changedCB): C++ comments => C comments.
(init_gconf): Do not deal with any GLib file descriptors, xg_select
does that now.

* gtkutil.c (xg_timer, xg_process_timeouts, xg_start_timer)
(xg_stop_timer, menu_grab_callback_cnt, menu_grab_callback)
(scroll_bar_button_cb): Remove.
(create_menus): C++ comments => C comments. Don't bind grab-notify
event.
(xg_create_scroll_bar): Don't bind button-press-event and
button-release-event.

* process.c: Include xgselect.h if defined (USE_GTK) ||
defined (HAVE_GCONF).
(wait_reading_process_output): Call xg_select for the same condition.

* xgselect.c (xg_select): New function to better integrate with
GLib/Gtk event handling.  Needed if GConf daemon dies/restarts.

* xgselect.h: New file, declare xg_select, xgselect_initialize.

* Makefile.in (XOBJ): Add xgselect.o.

1 files changed, 157 insertions, 0 deletions

diff --git a/src/xgselect.c b/src/xgselect.c
new file mode 100644
index 00000000000..3c5a99f8ed2
--- /dev/null
+++ b/src/xgselect.c
@@ -0,0 +1,157 @@
+/* Function for handling the GLib event loop.
+   Copyright (C) 2009
+     Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include "config.h"
+
+#if defined (USE_GTK) || defined (HAVE_GCONF)
+#include <glib.h>
+#include <errno.h>
+#include <setjmp.h>
+#include "xgselect.h"
+
+static GPollFD *gfds;
+static int gfds_size;
+
+int
+xg_select (max_fds, rfds, wfds, efds, timeout)
+     int max_fds;
+     SELECT_TYPE *rfds;
+     SELECT_TYPE *wfds;
+     SELECT_TYPE *efds;
+     EMACS_TIME *timeout;
+{
+  SELECT_TYPE all_rfds, all_wfds;
+  EMACS_TIME tmo, *tmop = timeout;
+
+  GMainContext *context = g_main_context_default ();
+  int have_wfds = wfds != NULL;
+  int n_gfds = 0, our_tmo = 0, retval = 0, our_fds = 0;
+  int prio, i, nfds, tmo_in_millisec;
+
+  if (rfds) memcpy (&all_rfds, rfds, sizeof (all_rfds));
+  else FD_ZERO (&all_rfds);
+  if (wfds) memcpy (&all_wfds, wfds, sizeof (all_rfds));
+  else FD_ZERO (&all_wfds);
+
+  /* Update event sources in GLib. */
+  g_main_context_pending (context);
+
+  do {
+    if (n_gfds > gfds_size) 
+      {
+        while (n_gfds > gfds_size) 
+          gfds_size *= 2;
+        xfree (gfds);
+        gfds = xmalloc (sizeof (*gfds) * gfds_size);
+      }
+
+    n_gfds = g_main_context_query (context,
+                                   G_PRIORITY_LOW,
+                                   &tmo_in_millisec,
+                                   gfds,
+                                   gfds_size);
+  } while (n_gfds > gfds_size);
+
+  for (i = 0; i < n_gfds; ++i) 
+    {
+      if (gfds[i].events & G_IO_IN)
+        {
+          FD_SET (gfds[i].fd, &all_rfds);
+          if (gfds[i].fd > max_fds) max_fds = gfds[i].fd;
+        }
+      if (gfds[i].events & G_IO_OUT)
+        {
+          FD_SET (gfds[i].fd, &all_wfds);
+          if (gfds[i].fd > max_fds) max_fds = gfds[i].fd;
+          have_wfds = 1;
+        }
+    }
+
+  if (tmo_in_millisec >= 0)
+    {
+      EMACS_SET_SECS_USECS (tmo, tmo_in_millisec/1000,
+                            1000 * (tmo_in_millisec % 1000));
+      if (!timeout) our_tmo = 1;
+      else
+        {
+          EMACS_TIME difference;
+          
+          EMACS_SUB_TIME (difference, tmo, *timeout);
+          if (EMACS_TIME_NEG_P (difference)) our_tmo = 1;
+        }
+
+      if (our_tmo) tmop = &tmo;
+    }
+
+  nfds = select (max_fds+1, &all_rfds, have_wfds ? &all_wfds : NULL,
+                 efds, tmop);
+
+  if (nfds < 0)
+    retval = nfds;
+  else if (nfds > 0) 
+    {
+      for (i = 0; i < max_fds+1; ++i)
+        {
+          if (FD_ISSET (i, &all_rfds))
+            {
+              if (rfds && FD_ISSET (i, rfds)) ++retval;
+              else ++our_fds;
+            }
+          if (have_wfds && FD_ISSET (i, &all_wfds))
+            {
+              if (wfds && FD_ISSET (i, wfds)) ++retval;
+              else ++our_fds;
+            }
+          if (efds && FD_ISSET (i, efds))
+            ++retval;
+        }
+    }
+
+  if (our_fds > 0 || (nfds == 0 && our_tmo))
+    {
+      
+      /* If Gtk+ is in use eventually gtk_main_iteration will be called,
+         unless retval is zero.  */
+#ifdef USE_GTK
+      if (retval == 0)
+#endif
+        while (g_main_context_pending (context))
+          g_main_context_dispatch (context);
+
+      /* To not have to recalculate timeout, return like this.  */
+      if (retval == 0) 
+        {
+          retval = -1;
+          errno = EINTR;
+        }
+    }
+
+  return retval;
+}
+#endif /* defined (USE_GTK) || defined (HAVE_GCONF) */
+
+void
+xgselect_initialize ()
+{
+#if defined (USE_GTK) || defined (HAVE_GCONF)
+  gfds_size = 128;
+  gfds = xmalloc (sizeof (*gfds)*gfds_size);
+#endif /* defined (USE_GTK) || defined (HAVE_GCONF) */
+}
+