initial

1 files changed, 1213 insertions, 0 deletions

diff --git a/src/terminal-util.c b/src/terminal-util.c
new file mode 100644
index 0000000..6bf6618
--- /dev/null
+++ b/src/terminal-util.c
@@ -0,0 +1,1213 @@
+/*
+ * Copyright © 2001, 2002 Havoc Pennington
+ * Copyright © 2002 Red Hat, Inc.
+ * Copyright © 2002 Sun Microsystems
+ * Copyright © 2003 Mariano Suarez-Alvarez
+ * Copyright © 2008 Christian Persch
+ *
+ * Mate-terminal 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.
+ *
+ * Mate-terminal 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+#include <glib.h>
+
+#include <gio/gio.h>
+#include <gtk/gtk.h>
+
+#include <mateconf/mateconf.h>
+
+#ifdef GDK_WINDOWING_X11
+#include <gdk/gdkx.h>
+#include <X11/Xatom.h>
+#endif
+
+#include "terminal-accels.h"
+#include "terminal-app.h"
+#include "terminal-intl.h"
+#include "terminal-util.h"
+#include "terminal-window.h"
+
+void
+terminal_util_set_unique_role (GtkWindow *window, const char *prefix)
+{
+  char *role;
+
+  role = g_strdup_printf ("%s-%d-%d-%d", prefix, getpid (), g_random_int (), (int) time (NULL));
+  gtk_window_set_role (window, role);
+  g_free (role);
+}
+
+/**
+ * terminal_util_show_error_dialog:
+ * @transient_parent: parent of the future dialog window;
+ * @weap_ptr: pointer to a #Widget pointer, to control the population.
+ * @error: a #GError, or %NULL
+ * @message_format: printf() style format string
+ *
+ * Create a #GtkMessageDialog window with the message, and present it, handling its buttons.
+ * If @weap_ptr is not #NULL, only create the dialog if <literal>*weap_ptr</literal> is #NULL 
+ * (and in that * case, set @weap_ptr to be a weak pointer to the new dialog), otherwise just 
+ * present <literal>*weak_ptr</literal>. Note that in this last case, the message <emph>will</emph>
+ * be changed.
+ */
+void
+terminal_util_show_error_dialog (GtkWindow *transient_parent, 
+                                 GtkWidget **weak_ptr,
+                                 GError *error,
+                                 const char *message_format, 
+                                 ...) 
+{
+  char *message;
+  va_list args;
+
+  if (message_format)
+    {
+      va_start (args, message_format);
+      message = g_strdup_vprintf (message_format, args);
+      va_end (args);
+    }
+  else message = NULL;
+
+  if (weak_ptr == NULL || *weak_ptr == NULL)
+    {
+      GtkWidget *dialog;
+      dialog = gtk_message_dialog_new (transient_parent,
+                                       GTK_DIALOG_DESTROY_WITH_PARENT,
+                                       GTK_MESSAGE_ERROR,
+                                       GTK_BUTTONS_OK,
+                                       message ? "%s" : NULL,
+				       message);
+
+      if (error != NULL)
+        gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
+                                                  "%s", error->message);
+
+      g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtk_widget_destroy), NULL);
+
+      if (weak_ptr != NULL)
+        {
+        *weak_ptr = dialog;
+        g_object_add_weak_pointer (G_OBJECT (dialog), (void**)weak_ptr);
+        }
+
+      gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
+      
+      gtk_widget_show_all (dialog);
+    }
+  else 
+    {
+      g_return_if_fail (GTK_IS_MESSAGE_DIALOG (*weak_ptr));
+
+      /* Sucks that there's no direct accessor for "text" property */
+      g_object_set (G_OBJECT (*weak_ptr), "text", message, NULL);
+
+      gtk_window_present (GTK_WINDOW (*weak_ptr));
+    }
+
+  g_free (message);
+}
+
+static gboolean
+open_url (GtkWindow *parent,
+          const char *uri,
+          guint32 user_time,
+          GError **error)
+{
+  GdkScreen *screen;
+
+  if (parent)
+    screen = gtk_widget_get_screen (GTK_WIDGET (parent));
+  else
+    screen = gdk_screen_get_default ();
+
+  return gtk_show_uri (screen, uri, user_time, error);
+}
+
+void
+terminal_util_show_help (const char *topic, 
+                         GtkWindow  *parent)
+{
+  GError *error = NULL;
+  const char *lang;
+  char *uri = NULL, *url;
+  guint i;
+ 
+  const char * const * langs = g_get_language_names ();
+  for (i = 0; langs[i]; i++) {
+    lang = langs[i];
+    if (strchr (lang, '.')) {
+      continue;
+    }
+ 
+    uri = g_build_filename (TERM_HELPDIR,
+                            "mate-terminal", /* DOC_MODULE */
+                            lang,
+                            "mate-terminal.xml",
+                            NULL);
+					
+    if (g_file_test (uri, G_FILE_TEST_EXISTS)) {
+      break;
+    }
+
+    g_free (uri);
+    uri = NULL;
+  }
+
+  if (!uri)
+    return;
+
+  if (topic) {
+    url = g_strdup_printf ("ghelp://%s?%s", uri, topic);
+  } else {
+    url = g_strdup_printf ("ghelp://%s", uri);
+  }
+
+  if (!open_url (GTK_WINDOW (parent), url, gtk_get_current_event_time (), &error))
+    {
+      terminal_util_show_error_dialog (GTK_WINDOW (parent), NULL, error,
+                                       _("There was an error displaying help"));
+      g_error_free (error);
+    }
+
+  g_free (uri);
+  g_free (url);
+}
+ 
+/* sets accessible name and description for the widget */
+
+void
+terminal_util_set_atk_name_description (GtkWidget  *widget,
+                                        const char *name,
+                                        const char *desc)
+{
+  AtkObject *obj;
+  
+  obj = gtk_widget_get_accessible (widget);
+
+  if (obj == NULL)
+    {
+      g_warning ("%s: for some reason widget has no GtkAccessible",
+                 G_STRFUNC);
+      return;
+    }
+
+  
+  if (!GTK_IS_ACCESSIBLE (obj))
+    return; /* This means GAIL is not loaded so we have the NoOp accessible */
+      
+  g_return_if_fail (GTK_IS_ACCESSIBLE (obj));  
+  if (desc)
+    atk_object_set_description (obj, desc);
+  if (name)
+    atk_object_set_name (obj, name);
+}
+
+void
+terminal_util_open_url (GtkWidget *parent,
+                        const char *orig_url,
+                        TerminalURLFlavour flavor,
+                        guint32 user_time)
+{
+  GError *error = NULL;
+  char *uri;
+
+  g_return_if_fail (orig_url != NULL);
+
+  switch (flavor)
+    {
+    case FLAVOR_DEFAULT_TO_HTTP:
+      uri = g_strdup_printf ("http:%s", orig_url);
+      break;
+    case FLAVOR_EMAIL:
+      if (g_ascii_strncasecmp ("mailto:", orig_url, 7) != 0)
+	uri = g_strdup_printf ("mailto:%s", orig_url);
+      else
+	uri = g_strdup (orig_url);
+      break;
+    case FLAVOR_VOIP_CALL:
+    case FLAVOR_AS_IS:
+      uri = g_strdup (orig_url);
+      break;
+    case FLAVOR_SKEY:
+      /* shouldn't get this */
+    default:
+      uri = NULL;
+      g_assert_not_reached ();
+    }
+
+  if (!open_url (GTK_WINDOW (parent), uri, user_time, &error))
+    {
+      terminal_util_show_error_dialog (GTK_WINDOW (parent), NULL, error,
+                                       _("Could not open the address “%s”"),
+                                       uri);
+
+      g_error_free (error);
+    }
+
+  g_free (uri);
+}
+
+/**
+ * terminal_util_resolve_relative_path:
+ * @path:
+ * @relative_path:
+ *
+ * Returns: a newly allocate string
+ */
+char *
+terminal_util_resolve_relative_path (const char *path,
+                                     const char *relative_path)
+{
+  GFile *file, *resolved_file;
+  char *resolved_path = NULL;
+
+  g_return_val_if_fail (relative_path != NULL, NULL);
+
+  if (path == NULL)
+    return g_strdup (relative_path);
+
+  file = g_file_new_for_path (path);
+  resolved_file = g_file_resolve_relative_path (file, relative_path);
+  g_object_unref (file);
+
+  if (resolved_file == NULL)
+    return NULL;
+
+  resolved_path = g_file_get_path (resolved_file);
+  g_object_unref (resolved_file);
+
+  return resolved_path;
+}
+
+/**
+ * terminal_util_transform_uris_to_quoted_fuse_paths:
+ * @uris:
+ *
+ * Transforms those URIs in @uris to shell-quoted paths that point to
+ * GIO fuse paths.
+ */
+void
+terminal_util_transform_uris_to_quoted_fuse_paths (char **uris)
+{
+  guint i;
+
+  if (!uris)
+    return;
+
+  for (i = 0; uris[i]; ++i)
+    {
+      GFile *file;
+      char *path;
+
+      file = g_file_new_for_uri (uris[i]);
+
+      if ((path = g_file_get_path (file)))
+        {
+          char *quoted;
+
+          quoted = g_shell_quote (path);
+          g_free (uris[i]);
+          g_free (path);
+
+          uris[i] = quoted;
+        }
+
+      g_object_unref (file);
+    }
+}
+
+char *
+terminal_util_concat_uris (char **uris,
+                           gsize *length)
+{
+  GString *string;
+  gsize len;
+  guint i;
+
+  len = 0;
+  for (i = 0; uris[i]; ++i)
+    len += strlen (uris[i]) + 1;
+
+  if (length)
+    *length = len;
+
+  string = g_string_sized_new (len + 1);
+  for (i = 0; uris[i]; ++i)
+    {
+      g_string_append (string, uris[i]);
+      g_string_append_c (string, ' ');
+    }
+
+  return g_string_free (string, FALSE);
+}
+
+char *
+terminal_util_get_licence_text (void)
+{
+  const gchar *license[] = {
+    N_("MATE Terminal 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."),
+    N_("MATE Terminal 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."),
+    N_("You should have received a copy of the GNU General Public License "
+       "along with MATE Terminal; if not, write to the Free Software Foundation, "
+       "Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA")
+  };
+
+  return g_strjoin ("\n\n", _(license[0]), _(license[1]), _(license[2]), NULL);
+}
+
+gboolean
+terminal_util_load_builder_file (const char *filename,
+                                 const char *object_name,
+                                 ...)
+{
+  char *path;
+  GtkBuilder *builder;
+  GError *error = NULL;
+  va_list args;
+
+  path = g_build_filename (TERM_PKGDATADIR, filename, NULL);
+  builder = gtk_builder_new ();
+  if (!gtk_builder_add_from_file (builder, path, &error)) {
+    g_warning ("Failed to load %s: %s\n", filename, error->message);
+    g_error_free (error);
+    g_free (path);
+    g_object_unref (builder);
+    return FALSE;
+  }
+  g_free (path);
+
+  va_start (args, object_name);
+
+  while (object_name) {
+    GObject **objectptr;
+
+    objectptr = va_arg (args, GObject**);
+    *objectptr = gtk_builder_get_object (builder, object_name);
+    if (!*objectptr) {
+      g_warning ("Failed to fetch object \"%s\"\n", object_name);
+      break;
+    }
+
+    object_name = va_arg (args, const char*);
+  }
+
+  va_end (args);
+
+  g_object_unref (builder);
+  return object_name == NULL;
+}
+
+gboolean
+terminal_util_dialog_response_on_delete (GtkWindow *widget)
+{
+  gtk_dialog_response (GTK_DIALOG (widget), GTK_RESPONSE_DELETE_EVENT);
+  return TRUE;
+}
+
+/* Like g_key_file_set_string, but escapes characters so that
+ * the stored string is ASCII. Use when the input string may not
+ * be UTF-8.
+ */
+void
+terminal_util_key_file_set_string_escape (GKeyFile *key_file,
+                                          const char *group,
+                                          const char *key,
+                                          const char *string)
+{
+  char *escaped;
+
+  /* FIXMEchpe: be more intelligent and only escape characters that aren't UTF-8 */
+  escaped = g_strescape (string, NULL);
+  g_key_file_set_string (key_file, group, key, escaped);
+  g_free (escaped);
+}
+
+char *
+terminal_util_key_file_get_string_unescape (GKeyFile *key_file,
+                                            const char *group,
+                                            const char *key,
+                                            GError **error)
+{
+  char *escaped, *unescaped;
+
+  escaped = g_key_file_get_string (key_file, group, key, error);
+  if (!escaped)
+    return NULL;
+
+  unescaped = g_strcompress (escaped);
+  g_free (escaped);
+
+  return unescaped;
+}
+
+void
+terminal_util_key_file_set_argv (GKeyFile *key_file,
+                                 const char *group,
+                                 const char *key,
+                                 int argc,
+                                 char **argv)
+{
+  char **quoted_argv;
+  char *flat;
+  int i;
+
+  if (argc < 0)
+    argc = g_strv_length (argv);
+
+  quoted_argv = g_new (char*, argc + 1);
+  for (i = 0; i < argc; ++i)
+    quoted_argv[i] = g_shell_quote (argv[i]);
+  quoted_argv[argc] = NULL;
+
+  flat = g_strjoinv (" ", quoted_argv);
+  terminal_util_key_file_set_string_escape (key_file, group, key, flat);
+
+  g_free (flat);
+  g_strfreev (quoted_argv);
+}
+
+char **
+terminal_util_key_file_get_argv (GKeyFile *key_file,
+                                 const char *group,
+                                 const char *key,
+                                 int *argc,
+                                 GError **error)
+{
+  char **argv;
+  char *flat;
+  gboolean retval;
+
+  flat = terminal_util_key_file_get_string_unescape (key_file, group, key, error);
+  if (!flat)
+    return NULL;
+
+  retval = g_shell_parse_argv (flat, argc, &argv, error);
+  g_free (flat);
+
+  if (retval)
+    return argv;
+
+  return NULL;
+}
+
+/* Proxy stuff */
+
+static char *
+conf_get_string (MateConfClient *conf,
+                 const char *key)
+{
+  char *value;
+  value = mateconf_client_get_string (conf, key, NULL);
+  if (G_UNLIKELY (value && *value == '\0'))
+    {
+      g_free (value);
+      value = NULL;
+    }
+  return value;
+}
+
+/*
+ * set_proxy_env:
+ * @env_table: a #GHashTable
+ * @key: the env var name
+ * @value: the env var value
+ *
+ * Adds @value for @key to @env_table, taking care to never overwrite an
+ * existing value for @key. @value is consumed.
+ */
+static void
+set_proxy_env (GHashTable *env_table,
+               const char *key,
+               char *value)
+{
+  char *key1 = NULL, *key2 = NULL;
+  char *value1 = NULL, *value2 = NULL;
+
+  if (!value)
+    return;
+
+  if (g_hash_table_lookup (env_table, key) == NULL)
+    key1 = g_strdup (key);
+
+  key2 = g_ascii_strup (key, -1);
+  if (g_hash_table_lookup (env_table, key) != NULL)
+    {
+      g_free (key2);
+      key2 = NULL;
+    }
+
+  if (key1 && key2)
+    {
+      value1 = value;
+      value2 = g_strdup (value);
+    }
+  else if (key1)
+    value1 = value;
+  else if (key2)
+    value2 = value;
+  else
+    g_free (value);
+
+  if (key1)
+    g_hash_table_replace (env_table, key1, value1);
+  if (key2)
+    g_hash_table_replace (env_table, key2, value2);
+}
+
+static void
+setup_http_proxy_env (GHashTable *env_table,
+                      MateConfClient *conf)
+{
+  gchar *host;
+  gint port;
+  GSList *ignore;
+
+  if (!mateconf_client_get_bool (conf, CONF_HTTP_PROXY_PREFIX "/use_http_proxy", NULL))
+    return;
+
+  host = conf_get_string (conf, CONF_HTTP_PROXY_PREFIX "/host");
+  port = mateconf_client_get_int (conf, CONF_HTTP_PROXY_PREFIX "/port", NULL);
+  if (host && port)
+    {
+      GString *buf = g_string_sized_new (64);
+      g_string_append (buf, "http://");
+
+      if (mateconf_client_get_bool (conf, CONF_HTTP_PROXY_PREFIX "/use_authentication", NULL))
+	{
+	  char *user, *password;
+	  user = conf_get_string (conf, CONF_HTTP_PROXY_PREFIX "/authentication_user");
+	  if (user)
+	    {
+	      g_string_append_uri_escaped (buf, user, NULL, TRUE);
+	      password = conf_get_string (conf, CONF_HTTP_PROXY_PREFIX "/authentication_password");
+	      if (password)
+		{
+		  g_string_append_c (buf, ':');
+		  g_string_append_uri_escaped (buf, password, NULL, TRUE);
+		  g_free (password);
+		}
+	      g_free (user);
+	      g_string_append_c (buf, '@');
+	    }
+	}
+      g_string_append_printf (buf, "%s:%d/", host, port);
+      set_proxy_env (env_table, "http_proxy", g_string_free (buf, FALSE));
+    }
+  g_free (host);
+
+  ignore = mateconf_client_get_list (conf, CONF_HTTP_PROXY_PREFIX "/ignore_hosts", MATECONF_VALUE_STRING, NULL);
+  if (ignore)
+    {
+      GString *buf = g_string_sized_new (64);
+      while (ignore != NULL)
+	{
+	  GSList *old;
+
+	  if (buf->len)
+	    g_string_append_c (buf, ',');
+	  g_string_append (buf, ignore->data);
+
+	  old = ignore;
+	  ignore = g_slist_next (ignore);
+	  g_free (old->data);
+	  g_slist_free_1 (old);
+	}
+      set_proxy_env (env_table, "no_proxy", g_string_free (buf, FALSE));
+    }
+}
+
+static void
+setup_https_proxy_env (GHashTable *env_table,
+                       MateConfClient *conf)
+{
+  gchar *host;
+  gint port;
+
+  host = conf_get_string (conf, CONF_PROXY_PREFIX "/secure_host");
+  port = mateconf_client_get_int (conf, CONF_PROXY_PREFIX "/secure_port", NULL);
+  if (host && port)
+    {
+      char *proxy;
+      /* Even though it's https, the proxy scheme is 'http'. See bug #624440. */
+      proxy = g_strdup_printf ("http://%s:%d/", host, port);
+      set_proxy_env (env_table, "https_proxy", proxy);
+    }
+  g_free (host);
+}
+
+static void
+setup_ftp_proxy_env (GHashTable *env_table,
+                     MateConfClient *conf)
+{
+  gchar *host;
+  gint port;
+
+  host = conf_get_string (conf, CONF_PROXY_PREFIX "/ftp_host");
+  port = mateconf_client_get_int (conf, CONF_PROXY_PREFIX "/ftp_port", NULL);
+  if (host && port)
+    {
+      char *proxy;
+      /* Even though it's ftp, the proxy scheme is 'http'. See bug #624440. */
+      proxy = g_strdup_printf ("http://%s:%d/", host, port);
+      set_proxy_env (env_table, "ftp_proxy", proxy);
+    }
+  g_free (host);
+}
+
+static void
+setup_socks_proxy_env (GHashTable *env_table,
+                       MateConfClient *conf)
+{
+  gchar *host;
+  gint port;
+
+  host = conf_get_string (conf, CONF_PROXY_PREFIX "/socks_host");
+  port = mateconf_client_get_int (conf, CONF_PROXY_PREFIX "/socks_port", NULL);
+  if (host && port)
+    {
+      char *proxy;
+      proxy = g_strdup_printf ("socks://%s:%d/", host, port);
+      set_proxy_env (env_table, "all_proxy", proxy);
+    }
+  g_free (host);
+}
+
+static void
+setup_autoconfig_proxy_env (GHashTable *env_table,
+                            MateConfClient *conf)
+{
+  /* XXX  Not sure what to do with this.  See bug #596688.
+  gchar *url;
+
+  url = conf_get_string (conf, CONF_PROXY_PREFIX "/autoconfig_url");
+  if (url)
+    {
+      char *proxy;
+      proxy = g_strdup_printf ("pac+%s", url);
+      set_proxy_env (env_table, "http_proxy", proxy);
+    }
+  g_free (url);
+  */
+}
+
+/**
+ * terminal_util_add_proxy_env:
+ * @env_table: a #GHashTable
+ *
+ * Adds the proxy env variables to @env_table.
+ */
+void
+terminal_util_add_proxy_env (GHashTable *env_table)
+{
+  char *proxymode;
+
+  MateConfClient *conf;
+  conf = mateconf_client_get_default ();
+
+  /* If mode is not manual, nothing to set */
+  proxymode = conf_get_string (conf, CONF_PROXY_PREFIX "/mode");
+  if (proxymode && 0 == strcmp (proxymode, "manual"))
+    {
+      setup_http_proxy_env (env_table, conf);
+      setup_https_proxy_env (env_table, conf);
+      setup_ftp_proxy_env (env_table, conf);
+      setup_socks_proxy_env (env_table, conf);
+    }
+  else if (proxymode && 0 == strcmp (proxymode, "auto"))
+    {
+      setup_autoconfig_proxy_env (env_table, conf);
+    }
+
+  g_free (proxymode);
+  g_object_unref (conf);
+}
+
+/* Bidirectional object/widget binding */
+
+typedef struct {
+  GObject *object;
+  const char *object_prop;
+  GtkWidget *widget;
+  gulong object_notify_id;
+  gulong widget_notify_id;
+  PropertyChangeFlags flags;
+} PropertyChange;
+
+static void
+property_change_free (PropertyChange *change)
+{
+  g_signal_handler_disconnect (change->object, change->object_notify_id);
+
+  g_slice_free (PropertyChange, change);
+}
+
+static gboolean
+transform_boolean (gboolean input,
+                   PropertyChangeFlags flags)
+{
+  if (flags & FLAG_INVERT_BOOL)
+    input = !input;
+
+  return input;
+}
+
+static void
+object_change_notify_cb (PropertyChange *change)
+{
+  GObject *object = change->object;
+  const char *object_prop = change->object_prop;
+  GtkWidget *widget = change->widget;
+
+  g_signal_handler_block (widget, change->widget_notify_id);
+
+  if (GTK_IS_RADIO_BUTTON (widget))
+    {
+      int ovalue, rvalue;
+
+      g_object_get (object, object_prop, &ovalue, NULL);
+      rvalue = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "enum-value"));
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), ovalue == rvalue);
+    }
+  else if (GTK_IS_TOGGLE_BUTTON (widget))
+    {
+      gboolean enabled;
+
+      g_object_get (object, object_prop, &enabled, NULL);
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
+                                    transform_boolean (enabled, change->flags));
+    }
+  else if (GTK_IS_SPIN_BUTTON (widget))
+    {
+      int value;
+
+      g_object_get (object, object_prop, &value, NULL);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), value);
+    }
+  else if (GTK_IS_ENTRY (widget))
+    {
+      char *text;
+
+      g_object_get (object, object_prop, &text, NULL);
+      gtk_entry_set_text (GTK_ENTRY (widget), text ? text : "");
+      g_free (text);
+    }
+  else if (GTK_IS_COMBO_BOX (widget))
+    {
+      int value;
+
+      g_object_get (object, object_prop, &value, NULL);
+      gtk_combo_box_set_active (GTK_COMBO_BOX (widget), value);
+    }
+  else if (GTK_IS_RANGE (widget))
+    {
+      double value;
+
+      g_object_get (object, object_prop, &value, NULL);
+      gtk_range_set_value (GTK_RANGE (widget), value);
+    }
+  else if (GTK_IS_COLOR_BUTTON (widget))
+    {
+      GdkColor *color;
+      GdkColor old_color;
+
+      g_object_get (object, object_prop, &color, NULL);
+      gtk_color_button_get_color (GTK_COLOR_BUTTON (widget), &old_color);
+
+      if (color && !gdk_color_equal (color, &old_color))
+        gtk_color_button_set_color (GTK_COLOR_BUTTON (widget), color);
+      if (color)
+        gdk_color_free (color);
+    }
+  else if (GTK_IS_FONT_BUTTON (widget))
+    {
+      PangoFontDescription *font_desc;
+      char *font;
+
+      g_object_get (object, object_prop, &font_desc, NULL);
+      if (!font_desc)
+        goto out;
+
+      font = pango_font_description_to_string (font_desc);
+      gtk_font_button_set_font_name (GTK_FONT_BUTTON (widget), font);
+      g_free (font);
+      pango_font_description_free (font_desc);
+    }
+  else if (GTK_IS_FILE_CHOOSER (widget))
+    {
+      char *name = NULL, *filename = NULL;
+
+      g_object_get (object, object_prop, &name, NULL);
+      if (name)
+        filename = g_filename_from_utf8 (name, -1, NULL, NULL, NULL);
+
+      if (filename)
+        gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (widget), filename);
+      else
+        gtk_file_chooser_unselect_all (GTK_FILE_CHOOSER (widget));
+      g_free (filename);
+      g_free (name);
+    }
+
+out:
+  g_signal_handler_unblock (widget, change->widget_notify_id);
+}
+
+static void
+widget_change_notify_cb (PropertyChange *change)
+{
+  GObject *object = change->object;
+  const char *object_prop = change->object_prop;
+  GtkWidget *widget = change->widget;
+
+  g_signal_handler_block (change->object, change->object_notify_id);
+
+  if (GTK_IS_RADIO_BUTTON (widget))
+    {
+      gboolean active;
+      int value;
+
+      active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
+      if (!active)
+        goto out;
+
+      value = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "enum-value"));
+      g_object_set (object, object_prop, value, NULL);
+    }
+  else if (GTK_IS_TOGGLE_BUTTON (widget))
+    {
+      gboolean enabled;
+
+      enabled = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
+      g_object_set (object, object_prop, transform_boolean (enabled, change->flags), NULL);
+    }
+  else if (GTK_IS_SPIN_BUTTON (widget))
+    {
+      int value;
+
+      value = (int) gtk_spin_button_get_value (GTK_SPIN_BUTTON (widget));
+      g_object_set (object, object_prop, value, NULL);
+    }
+  else if (GTK_IS_ENTRY (widget))
+    {
+      const char *text;
+
+      text = gtk_entry_get_text (GTK_ENTRY (widget));
+      g_object_set (object, object_prop, text, NULL);
+    }
+  else if (GTK_IS_COMBO_BOX (widget))
+    {
+      int value;
+
+      value = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
+      g_object_set (object, object_prop, value, NULL);
+    }
+  else if (GTK_IS_COLOR_BUTTON (widget))
+    {
+      GdkColor color;
+
+      gtk_color_button_get_color (GTK_COLOR_BUTTON (widget), &color);
+      g_object_set (object, object_prop, &color, NULL);
+    }
+  else if (GTK_IS_FONT_BUTTON (widget))
+    {
+      PangoFontDescription *font_desc;
+      const char *font;
+
+      font = gtk_font_button_get_font_name (GTK_FONT_BUTTON (widget));
+      font_desc = pango_font_description_from_string (font);
+      g_object_set (object, object_prop, font_desc, NULL);
+      pango_font_description_free (font_desc);
+    }
+  else if (GTK_IS_RANGE (widget))
+    {
+      double value;
+
+      value = gtk_range_get_value (GTK_RANGE (widget));
+      g_object_set (object, object_prop, value, NULL);
+    }
+  else if (GTK_IS_FILE_CHOOSER (widget))
+    {
+      char *filename, *name = NULL;
+
+      filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (widget));
+      if (filename)
+        name = g_filename_to_utf8 (filename, -1, NULL, NULL, NULL);
+
+      g_object_set (object, object_prop, name, NULL);
+      g_free (filename);
+      g_free (name);
+    }
+
+out:
+  g_signal_handler_unblock (change->object, change->object_notify_id);
+}
+
+void
+terminal_util_bind_object_property_to_widget (GObject *object,
+                                              const char *object_prop,
+                                              GtkWidget *widget,
+                                              PropertyChangeFlags flags)
+{
+  PropertyChange *change;
+  const char *signal_name;
+  char notify_signal_name[64];
+
+  change = g_slice_new0 (PropertyChange);
+
+  change->widget = widget;
+  g_assert (g_object_get_data (G_OBJECT (widget), "GT:PCD") == NULL);
+  g_object_set_data_full (G_OBJECT (widget), "GT:PCD", change, (GDestroyNotify) property_change_free);
+
+  if (GTK_IS_TOGGLE_BUTTON (widget))
+    signal_name = "notify::active";
+  else if (GTK_IS_SPIN_BUTTON (widget))
+    signal_name = "notify::value";
+  else if (GTK_IS_ENTRY (widget))
+    signal_name = "notify::text";
+  else if (GTK_IS_COMBO_BOX (widget))
+    signal_name = "notify::active";
+  else if (GTK_IS_COLOR_BUTTON (widget))
+    signal_name = "notify::color";
+  else if (GTK_IS_FONT_BUTTON (widget))
+    signal_name = "notify::font-name";
+  else if (GTK_IS_RANGE (widget))
+    signal_name = "value-changed";
+  else if (GTK_IS_FILE_CHOOSER_BUTTON (widget))
+    signal_name = "file-set";
+  else if (GTK_IS_FILE_CHOOSER (widget))
+    signal_name = "selection-changed";
+  else
+    g_assert_not_reached ();
+
+  change->widget_notify_id = g_signal_connect_swapped (widget, signal_name, G_CALLBACK (widget_change_notify_cb), change);
+
+  change->object = object;
+  change->flags = flags;
+  change->object_prop = object_prop;
+
+  g_snprintf (notify_signal_name, sizeof (notify_signal_name), "notify::%s", object_prop);
+  object_change_notify_cb (change);
+  change->object_notify_id = g_signal_connect_swapped (object, notify_signal_name, G_CALLBACK (object_change_notify_cb), change);
+}
+
+#ifdef GDK_WINDOWING_X11
+
+/* We don't want to hop desktops when we unrealize/realize.
+ * So we need to save and restore the value of NET_WM_DESKTOP. This isn't
+ * exposed through GDK.
+ */
+gboolean
+terminal_util_x11_get_net_wm_desktop (GdkWindow *window,
+				      guint32   *desktop)
+{
+  GdkDisplay *display = gdk_drawable_get_display (window);
+  Atom type;
+  int format;
+  guchar *data;
+  gulong n_items, bytes_after;
+  gboolean result = FALSE;
+
+  if (XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),
+			  GDK_DRAWABLE_XID (window),
+			  gdk_x11_get_xatom_by_name_for_display (display,
+								 "_NET_WM_DESKTOP"),
+			  0, G_MAXLONG, False, AnyPropertyType,
+			  &type, &format, &n_items, &bytes_after, &data) == Success &&
+      type != None)
+    {
+      if (type == XA_CARDINAL && format == 32 && n_items == 1)
+	{
+	  *desktop = *(gulong *)data;
+	  result = TRUE;
+	}
+
+      XFree (data);
+    }
+
+  return result;
+}
+
+void
+terminal_util_x11_set_net_wm_desktop (GdkWindow *window,
+				      guint32    desktop)
+{
+  /* We can't change the current desktop before mapping our window,
+   * because GDK has the annoying habit of clearing _NET_WM_DESKTOP
+   * before mapping a GdkWindow, So we we have to do it after instead.
+   *
+   * However, doing it after is different whether or not we have a
+   * window manager (if we don't have a window manager, we have to
+   * set the _NET_WM_DESKTOP property so that it picks it up when
+   * it starts)
+   *
+   * http://bugzilla.mate.org/show_bug.cgi?id=586311 asks for GTK+
+   * to just handle everything behind the scenes including the desktop.
+   */
+  GdkScreen *screen = gdk_drawable_get_screen (window);
+  GdkDisplay *display = gdk_screen_get_display (screen);
+  Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
+  char *wm_selection_name;
+  Atom wm_selection;
+  gboolean have_wm;
+
+  wm_selection_name = g_strdup_printf ("WM_S%d", gdk_screen_get_number (screen));
+  wm_selection = gdk_x11_get_xatom_by_name_for_display (display, wm_selection_name);
+  g_free(wm_selection_name);
+
+  XGrabServer (xdisplay);
+
+  have_wm = XGetSelectionOwner (xdisplay, wm_selection) != None;
+
+  if (have_wm)
+    {
+      /* code borrowed from GDK
+       */
+      XClientMessageEvent xclient;
+
+      memset (&xclient, 0, sizeof (xclient));
+      xclient.type = ClientMessage;
+      xclient.serial = 0;
+      xclient.send_event = True;
+      xclient.window = GDK_WINDOW_XWINDOW (window);
+      xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_DESKTOP");
+      xclient.format = 32;
+
+      xclient.data.l[0] = desktop;
+      xclient.data.l[1] = 0;
+      xclient.data.l[2] = 0;
+      xclient.data.l[3] = 0;
+      xclient.data.l[4] = 0;
+
+      XSendEvent (xdisplay,
+		  GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (screen)),
+		  False,
+		  SubstructureRedirectMask | SubstructureNotifyMask,
+		  (XEvent *)&xclient);
+    }
+  else
+    {
+      gulong long_desktop = desktop;
+
+      XChangeProperty (xdisplay,
+		       GDK_DRAWABLE_XID (window),
+		       gdk_x11_get_xatom_by_name_for_display (display,
+							      "_NET_WM_DESKTOP"),
+		       XA_CARDINAL, 32, PropModeReplace,
+		       (guchar *)&long_desktop, 1);
+    }
+
+  XUngrabServer (xdisplay);
+  XFlush (xdisplay);
+}
+
+/* Asks the window manager to turn off the "demands attention" state on the window.
+ *
+ * This only works for windows that are currently window managed; if the window
+ * is unmapped (in the withdrawn state) it would be necessary to change _NET_WM_STATE
+ * directly.
+ */
+void
+terminal_util_x11_clear_demands_attention (GdkWindow *window)
+{
+  GdkScreen *screen = gdk_drawable_get_screen (window);
+  GdkDisplay *display = gdk_screen_get_display (screen);
+  XClientMessageEvent xclient;
+
+  memset (&xclient, 0, sizeof (xclient));
+  xclient.type = ClientMessage;
+  xclient.serial = 0;
+  xclient.send_event = True;
+  xclient.window = GDK_WINDOW_XWINDOW (window);
+  xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE");
+  xclient.format = 32;
+
+  xclient.data.l[0] = 0; /* _NET_WM_STATE_REMOVE */
+  xclient.data.l[1] = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE_DEMANDS_ATTENTION");
+  xclient.data.l[2] = 0;
+  xclient.data.l[3] = 0;
+  xclient.data.l[4] = 0;
+
+  XSendEvent (GDK_DISPLAY_XDISPLAY (display),
+	      GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (screen)),
+	      False,
+	      SubstructureRedirectMask | SubstructureNotifyMask,
+	      (XEvent *)&xclient);
+}
+
+/* Check if a GdkWindow is minimized. This is a workaround for a
+ * GDK bug/misfeature. gdk_window_get_state (window) has the
+ * GDK_WINDOW_STATE_ICONIFIED bit for all unmapped windows,
+ * even windows on another desktop.
+ *
+ * http://bugzilla.mate.org/show_bug.cgi?id=586664
+ *
+ * Code to read _NET_WM_STATE adapted from GDK
+ */
+gboolean
+terminal_util_x11_window_is_minimized (GdkWindow *window)
+{
+  GdkDisplay *display = gdk_drawable_get_display (window);
+
+  Atom type;
+  gint format;
+  gulong nitems;
+  gulong bytes_after;
+  guchar *data;
+  Atom *atoms = NULL;
+  gulong i;
+
+  gboolean minimized = FALSE;
+
+  type = None;
+  gdk_error_trap_push ();
+  XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window),
+                      gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE"),
+                      0, G_MAXLONG, False, XA_ATOM, &type, &format, &nitems,
+                      &bytes_after, &data);
+  gdk_error_trap_pop ();
+
+  if (type != None)
+    {
+      Atom hidden_atom = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE_HIDDEN");
+
+      atoms = (Atom *)data;
+
+      for (i = 0; i < nitems; i++)
+        {
+          if (atoms[i] == hidden_atom)
+            minimized = TRUE;
+
+          ++i;
+        }
+
+      XFree (atoms);
+    }
+
+  return minimized;
+}
+
+#endif /* GDK_WINDOWING_X11 */