Adding upstream version 3.46.8.upstream/3.46.8upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1945 insertions, 0 deletions

diff --git a/src/terminal-util.cc b/src/terminal-util.cc
new file mode 100644
index 0000000..3ee8f51
--- /dev/null
+++ b/src/terminal-util.cc
@@ -0,0 +1,1945 @@
+/*
+ * Copyright © 2001, 2002 Havoc Pennington
+ * Copyright © 2002 Red Hat, Inc.
+ * Copyright © 2002 Sun Microsystems
+ * Copyright © 2003 Mariano Suarez-Alvarez
+ * Copyright © 2008, 2011 Christian Persch
+ *
+ * This program 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.
+ *
+ * This program 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 <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <langinfo.h>
+#include <errno.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+
+#include <gio/gio.h>
+#include <gtk/gtk.h>
+
+#include <gdesktop-enums.h>
+
+#include "terminal-accels.hh"
+#include "terminal-app.hh"
+#include "terminal-client-utils.hh"
+#include "terminal-debug.hh"
+#include "terminal-defines.hh"
+#include "terminal-intl.hh"
+#include "terminal-util.hh"
+#include "terminal-version.hh"
+#include "terminal-libgsystem.hh"
+
+/**
+ * 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 %nullptr
+ * @message_format: printf() style format string
+ *
+ * Create a #GtkMessageDialog window with the message, and present it, handling its buttons.
+ * If @weap_ptr is not #nullptr, only create the dialog if <literal>*weap_ptr</literal> is #nullptr 
+ * (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, 
+                                 ...) 
+{
+  gs_free 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 = nullptr;
+
+  if (weak_ptr == nullptr || *weak_ptr == nullptr)
+    {
+      GtkWidget *dialog;
+      dialog = gtk_message_dialog_new (transient_parent,
+                                       GTK_DIALOG_DESTROY_WITH_PARENT,
+                                       GTK_MESSAGE_ERROR,
+                                       GTK_BUTTONS_OK,
+                                       message ? "%s" : nullptr,
+				       message);
+
+      if (error != nullptr)
+        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), nullptr);
+
+      if (weak_ptr != nullptr)
+        {
+        *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, nullptr);
+
+      gtk_window_present (GTK_WINDOW (*weak_ptr));
+    }
+}
+
+static gboolean
+open_url (GtkWindow *parent,
+          const char *uri,
+          guint32 user_time,
+          GError **error)
+{
+  GdkScreen *screen;
+  gs_free char *uri_fixed;
+
+  if (parent)
+    screen = gtk_widget_get_screen (GTK_WIDGET (parent));
+  else
+    screen = gdk_screen_get_default ();
+
+  uri_fixed = terminal_util_uri_fixup (uri, error);
+  if (uri_fixed == nullptr)
+    return FALSE;
+
+  return gtk_show_uri (screen, uri_fixed, user_time, error);
+}
+
+void
+terminal_util_show_help (const char *topic)
+{
+  gs_free_error GError *error = nullptr;
+  gs_free char *uri;
+
+  if (topic) {
+    uri = g_strdup_printf ("help:gnome-terminal/%s", topic);
+  } else {
+    uri = g_strdup ("help:gnome-terminal");
+  }
+
+  if (!open_url (nullptr, uri, gtk_get_current_event_time (), &error))
+    {
+      terminal_util_show_error_dialog (nullptr, nullptr, error,
+                                       _("There was an error displaying help"));
+    }
+}
+
+#define ABOUT_GROUP "About"
+#define ABOUT_URL "https://wiki.gnome.org/Apps/Terminal"
+#define EMAILIFY(string) (g_strdelimit ((string), "%", '@'))
+
+void
+terminal_util_show_about (void)
+{
+  static const char copyright[] =
+    "Copyright © 2002–2004 Havoc Pennington\n"
+    "Copyright © 2003–2004, 2007 Mariano Suárez-Alvarez\n"
+    "Copyright © 2006 Guilherme de S. Pastore\n"
+    "Copyright © 2007–2019 Christian Persch\n"
+    "Copyright © 2013–2019 Egmont Koblinger";
+  char *licence_text;
+  GKeyFile *key_file;
+  GBytes *bytes;
+  const guint8 *data;
+  gsize data_len;
+  GError *error = nullptr;
+  char **authors, **contributors, **artists, **documenters, **array_strv;
+  gsize n_authors = 0, n_contributors = 0, n_artists = 0, n_documenters = 0 , i;
+  GPtrArray *array;
+  gs_free char *comment;
+  gs_free char *version;
+  gs_free char *vte_version;
+  GtkWindow *dialog;
+
+  bytes = g_resources_lookup_data (TERMINAL_RESOURCES_PATH_PREFIX "/ui/terminal.about",
+                                   G_RESOURCE_LOOKUP_FLAGS_NONE,
+                                   &error);
+  g_assert_no_error (error);
+
+  data = (guint8 const*)g_bytes_get_data (bytes, &data_len);
+  key_file = g_key_file_new ();
+  g_key_file_load_from_data (key_file, (const char *) data, data_len, GKeyFileFlags(0), &error);
+  g_assert_no_error (error);
+
+  authors = g_key_file_get_string_list (key_file, ABOUT_GROUP, "Authors", &n_authors, nullptr);
+  contributors = g_key_file_get_string_list (key_file, ABOUT_GROUP, "Contributors", &n_contributors, nullptr);
+  artists = g_key_file_get_string_list (key_file, ABOUT_GROUP, "Artists", &n_artists, nullptr);
+  documenters = g_key_file_get_string_list (key_file, ABOUT_GROUP, "Documenters", &n_documenters, nullptr);
+
+  g_key_file_free (key_file);
+  g_bytes_unref (bytes);
+
+  array = g_ptr_array_new ();
+
+  for (i = 0; i < n_authors; ++i)
+    g_ptr_array_add (array, EMAILIFY (authors[i]));
+  g_free (authors); /* strings are now owned by the array */
+
+  if (n_contributors > 0)
+  {
+    g_ptr_array_add (array, g_strdup (""));
+    g_ptr_array_add (array, g_strdup (_("Contributors:")));
+    for (i = 0; i < n_contributors; ++i)
+      g_ptr_array_add (array, EMAILIFY (contributors[i]));
+  }
+  g_free (contributors); /* strings are now owned by the array */
+
+  g_ptr_array_add (array, nullptr);
+  array_strv = (char **) g_ptr_array_free (array, FALSE);
+
+  for (i = 0; i < n_artists; ++i)
+    artists[i] = EMAILIFY (artists[i]);
+  for (i = 0; i < n_documenters; ++i)
+    documenters[i] = EMAILIFY (documenters[i]);
+
+  licence_text = terminal_util_get_licence_text ();
+
+  /* gnome 40 corresponds to g-t 3.40.x. After that, gnome version
+   * increases by 1 while the g-t minor version increases by 2 between
+   * stable releases.
+   */
+  auto const gnome_version = 40 + (TERMINAL_MINOR_VERSION - 40 + 1) / 2;
+  version = g_strdup_printf (_("Version %s for GNOME %d"),
+                             VERSION,
+                             gnome_version);
+
+  vte_version = g_strdup_printf (_("Using VTE version %u.%u.%u"),
+                                 vte_get_major_version (),
+                                 vte_get_minor_version (),
+                                 vte_get_micro_version ());
+
+  comment = g_strdup_printf("%s\n%s %s",
+                            _("A terminal emulator for the GNOME desktop"),
+                            vte_version,
+                            vte_get_features ());
+
+  dialog = (GtkWindow*)g_object_new (GTK_TYPE_ABOUT_DIALOG,
+                         /* Hold the application while the window is shown */
+                         "application", terminal_app_get (),
+                         "program-name", _("GNOME Terminal"),
+                         "copyright", copyright,
+                         "comments", comment,
+                         "version", version,
+                         "authors", array_strv,
+                         "artists", artists,
+                         "documenters", documenters,
+                         "license", licence_text,
+                         "wrap-license", TRUE,
+                         "website", ABOUT_URL,
+                         "translator-credits", _("translator-credits"),
+                         "logo-icon-name", GNOME_TERMINAL_ICON_NAME,
+                         nullptr);
+
+  g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), nullptr);
+  gtk_window_present (dialog);
+
+  g_strfreev (array_strv);
+  g_strfreev (artists);
+  g_strfreev (documenters);
+  g_free (licence_text);
+}
+
+/* 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 == nullptr)
+    {
+      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,
+                        TerminalURLFlavor flavor,
+                        guint32 user_time)
+{
+  gs_free_error GError *error = nullptr;
+  gs_free char *uri = nullptr;
+
+  g_return_if_fail (orig_url != nullptr);
+
+  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;
+    default:
+      uri = nullptr;
+      g_assert_not_reached ();
+    }
+
+  if (!open_url (GTK_WINDOW (parent), uri, user_time, &error))
+    {
+      terminal_util_show_error_dialog (GTK_WINDOW (parent), nullptr, error,
+                                       _("Could not open the address “%s”"),
+                                       uri);
+    }
+}
+
+/**
+ * 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)
+    {
+      gs_unref_object GFile *file;
+      gs_free char *path;
+
+      file = g_file_new_for_uri (uris[i]);
+
+      path = g_file_get_path (file);
+      if (path)
+        {
+          char *quoted;
+
+          quoted = g_shell_quote (path);
+          g_free (uris[i]);
+
+          uris[i] = quoted;
+        }
+    }
+}
+
+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_("GNOME 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_("GNOME 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 GNOME Terminal.  If not, see <http://www.gnu.org/licenses/>.")
+  };
+
+  return g_strjoin ("\n\n", _(license[0]), _(license[1]), _(license[2]), nullptr);
+}
+
+static void
+main_object_destroy_cb (GtkWidget *widget)
+{
+  g_object_set_data (G_OBJECT (widget), "builder", nullptr);
+}
+
+GtkBuilder *
+terminal_util_load_widgets_resource (const char *path,
+                                     const char *main_object_name,
+                                     const char *object_name,
+                                     ...)
+{
+  GtkBuilder *builder;
+  GError *error = nullptr;
+  va_list args;
+
+  builder = gtk_builder_new ();
+  gtk_builder_add_from_resource (builder, path, &error);
+  g_assert_no_error (error);
+
+  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_error ("Failed to fetch object \"%s\" from resource \"%s\"\n", object_name, path);
+
+    object_name = va_arg (args, const char*);
+  }
+
+  va_end (args);
+
+  if (main_object_name) {
+    GObject *main_object;
+    GtkWidget *action_area;
+
+    main_object = gtk_builder_get_object (builder, main_object_name);
+    g_object_set_data_full (main_object, "builder", g_object_ref (builder), (GDestroyNotify) g_object_unref);
+    g_signal_connect (main_object, "destroy", G_CALLBACK (main_object_destroy_cb), nullptr);
+
+    /* Fixup dialogue padding, #735242 */
+    if (GTK_IS_DIALOG (main_object) &&
+        (action_area = (GtkWidget *) gtk_builder_get_object (builder, "dialog-action-area"))) {
+      gtk_widget_set_margin_start  (action_area, 5);
+      gtk_widget_set_margin_end    (action_area, 5);
+      gtk_widget_set_margin_top    (action_area, 5);
+      gtk_widget_set_margin_bottom (action_area, 5);
+    }
+  }
+  return builder;
+}
+
+void
+terminal_util_load_objects_resource (const char *path,
+                                     const char *object_name,
+                                     ...)
+{
+  gs_unref_object GtkBuilder *builder;
+  GError *error = nullptr;
+  va_list args;
+
+  builder = gtk_builder_new ();
+  gtk_builder_add_from_resource (builder, path, &error);
+  g_assert_no_error (error);
+
+  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_object_ref (*objectptr);
+    else
+      g_error ("Failed to fetch object \"%s\" from resource \"%s\"\n", object_name, path);
+
+    object_name = va_arg (args, const char*);
+  }
+
+  va_end (args);
+}
+
+gboolean
+terminal_util_dialog_response_on_delete (GtkWindow *widget)
+{
+  gtk_dialog_response (GTK_DIALOG (widget), GTK_RESPONSE_DELETE_EVENT);
+  return TRUE;
+}
+
+void
+terminal_util_dialog_focus_widget (GtkBuilder *builder,
+                                   const char *widget_name)
+{
+  GtkWidget *widget, *page, *page_parent;
+
+  if (widget_name == nullptr)
+    return;
+
+  widget = GTK_WIDGET (gtk_builder_get_object (builder, widget_name));
+  if (widget == nullptr)
+    return;
+
+  page = widget;
+  while (page != nullptr &&
+         (page_parent = gtk_widget_get_parent (page)) != nullptr &&
+         !GTK_IS_NOTEBOOK (page_parent))
+    page = page_parent;
+
+  page_parent = gtk_widget_get_parent (page);
+  if (page != nullptr && GTK_IS_NOTEBOOK (page_parent)) {
+    GtkNotebook *notebook;
+
+    notebook = GTK_NOTEBOOK (page_parent);
+    gtk_notebook_set_current_page (notebook, gtk_notebook_page_num (notebook, page));
+  }
+
+  if (gtk_widget_is_sensitive (widget))
+    gtk_widget_grab_focus (widget);
+}
+
+/* Proxy stuff */
+
+/*
+ * 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 /* consumed */)
+{
+  char *key1 = nullptr, *key2 = nullptr;
+  char *value1 = nullptr, *value2 = nullptr;
+
+  if (!value)
+    return;
+
+  if (g_hash_table_lookup (env_table, key) == nullptr)
+    key1 = g_strdup (key);
+
+  key2 = g_ascii_strup (key, -1);
+  if (g_hash_table_lookup (env_table, key) != nullptr)
+    {
+      g_free (key2);
+      key2 = nullptr;
+    }
+
+  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_proxy_env (TerminalApp* app,
+                 TerminalProxyProtocol protocol,
+                 const char *proxy_scheme,
+                 const char *env_name,
+                 GHashTable *env_table)
+{
+  GString *buf;
+  gs_free char *host;
+  int port;
+
+  gboolean is_http = (protocol == TERMINAL_PROXY_HTTP);
+
+  GSettings *child_settings = terminal_app_get_proxy_settings_for_protocol(app, protocol);
+
+  host = g_settings_get_string (child_settings, "host");
+  port = g_settings_get_int (child_settings, "port");
+  if (host[0] == '\0' || port == 0)
+    return;
+
+  buf = g_string_sized_new (64);
+
+  g_string_append_printf (buf, "%s://", proxy_scheme);
+
+  if (is_http &&
+      g_settings_get_boolean (child_settings, "use-authentication"))
+    {
+      gs_free char *user;
+
+      user = g_settings_get_string (child_settings, "authentication-user");
+      if (user[0])
+        {
+          gs_free char *password;
+
+          g_string_append_uri_escaped (buf, user, nullptr, TRUE);
+
+          password = g_settings_get_string (child_settings, "authentication-password");
+          if (password[0])
+            {
+              g_string_append_c (buf, ':');
+              g_string_append_uri_escaped (buf, password, nullptr, TRUE);
+            }
+          g_string_append_c (buf, '@');
+        }
+    }
+
+  g_string_append_printf (buf, "%s:%d/", host, port);
+  set_proxy_env (env_table, env_name, g_string_free (buf, FALSE));
+}
+
+static void
+setup_ignore_proxy_env (GSettings *proxy_settings,
+                        GHashTable *env_table)
+{
+  GString *buf;
+  gs_strfreev char **ignore;
+  int i;
+
+  g_settings_get (proxy_settings, "ignore-hosts", "^as", &ignore);
+  if (ignore == nullptr)
+    return;
+
+  buf = g_string_sized_new (64);
+  for (i = 0; ignore[i] != nullptr; ++i)
+    {
+      if (buf->len)
+        g_string_append_c (buf, ',');
+      g_string_append (buf, ignore[i]);
+    }
+
+  set_proxy_env (env_table, "no_proxy", g_string_free (buf, FALSE));
+}
+
+/**
+ * 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)
+{
+  auto const app = terminal_app_get();
+  auto const proxy_settings = terminal_app_get_proxy_settings(app);
+  auto const mode = GDesktopProxyMode(g_settings_get_enum (proxy_settings, "mode"));
+
+  if (mode == G_DESKTOP_PROXY_MODE_MANUAL)
+    {
+      setup_proxy_env (app, TERMINAL_PROXY_HTTP, "http", "http_proxy", env_table);
+      /* Even though it's https, the proxy scheme is 'http'. See bug #624440. */
+      setup_proxy_env (app, TERMINAL_PROXY_HTTPS, "http", "https_proxy", env_table);
+      /* Even though it's ftp, the proxy scheme is 'http'. See bug #624440. */
+      setup_proxy_env (app, TERMINAL_PROXY_FTP, "http", "ftp_proxy", env_table);
+      setup_proxy_env (app, TERMINAL_PROXY_SOCKS, "socks", "all_proxy", env_table);
+      setup_ignore_proxy_env (proxy_settings, env_table);
+    }
+  else if (mode == G_DESKTOP_PROXY_MODE_AUTO)
+    {
+      /* Not supported */
+    }
+}
+
+/**
+ * terminal_util_get_etc_shells:
+ *
+ * Returns: (transfer full) the contents of /etc/shells
+ */
+char **
+terminal_util_get_etc_shells (void)
+{
+  GError *err = nullptr;
+  gsize len;
+  gs_free char *contents = nullptr;
+  char *str, *nl, *end;
+  GPtrArray *arr;
+
+  if (!g_file_get_contents ("/etc/shells", &contents, &len, &err) || len == 0) {
+    /* Defaults as per man:getusershell(3) */
+    char *default_shells[3] = {
+      (char*) "/bin/sh",
+      (char*) "/bin/csh",
+      nullptr
+    };
+    return g_strdupv (default_shells);
+  }
+
+  arr = g_ptr_array_new ();
+  str = contents;
+  end = contents + len;
+  while (str < end && (nl = strchr (str, '\n')) != nullptr) {
+    if (str != nl) /* non-empty? */
+      g_ptr_array_add (arr, g_strndup (str, nl - str));
+    str = nl + 1;
+  }
+  /* Anything non-empty left? */
+  if (str < end && str[0])
+    g_ptr_array_add (arr, g_strdup (str));
+
+  g_ptr_array_add (arr, nullptr);
+  return (char **) g_ptr_array_free (arr, FALSE);
+}
+
+/**
+ * terminal_util_get_is_shell:
+ * @command: a string
+ *
+ * Returns wether @command is a valid shell as defined by the contents of /etc/shells.
+ *
+ * Returns: whether @command is a shell
+ */
+gboolean
+terminal_util_get_is_shell (const char *command)
+{
+  gs_strfreev char **shells;
+  guint i;
+
+  shells = terminal_util_get_etc_shells ();
+  if (shells == nullptr)
+    return FALSE;
+
+  for (i = 0; shells[i]; i++)
+    if (g_str_equal (command, shells[i]))
+      return TRUE;
+
+  return FALSE;
+}
+
+static gboolean
+s_to_rgba (GVariant *variant,
+           gpointer *result,
+           gpointer  user_data)
+{
+  GdkRGBA *color = (GdkRGBA*)user_data;
+  const char *str;
+
+  if (variant == nullptr) {
+    /* Fallback */
+    *result = nullptr;
+    return TRUE;
+  }
+
+  g_variant_get (variant, "&s", &str);
+  if (!gdk_rgba_parse (color, str))
+    return FALSE;
+
+  color->alpha = 1.0;
+  *result = color;
+  return TRUE;
+}
+
+/**
+ * terminal_g_settings_get_rgba:
+ * @settings: a #GSettings
+ * @key: a valid key in @settings of type "s"
+ * @color: location to store the parsed color
+ *
+ * Gets a color from @key in @settings.
+ *
+ * Returns: @color if parsing succeeded, or %nullptr otherwise
+ */
+const GdkRGBA *
+terminal_g_settings_get_rgba (GSettings  *settings,
+                              const char *key,
+                              GdkRGBA    *color)
+{
+  g_return_val_if_fail (color != nullptr, FALSE);
+
+  return (GdkRGBA const*)g_settings_get_mapped (settings, key,
+						s_to_rgba,
+						color);
+}
+
+/**
+ * terminal_g_settings_set_rgba:
+ * @settings: a #GSettings
+ * @key: a valid key in @settings of type "s"
+ * @color: a #GdkRGBA
+ *
+ * Sets a color in @key in @settings.
+ */
+void
+terminal_g_settings_set_rgba (GSettings  *settings,
+                              const char *key,
+                              const GdkRGBA *color)
+{
+  gs_free char *str;
+
+  str = gdk_rgba_to_string (color);
+  g_settings_set_string (settings, key, str);
+}
+
+static gboolean
+as_to_rgba_palette (GVariant *variant,
+                    gpointer *result,
+                    gpointer user_data)
+{
+  gsize *n_colors = (gsize*)user_data;
+  gs_free GdkRGBA *colors = nullptr;
+  gsize n = 0;
+  GVariantIter iter;
+  const char *str;
+  gsize i;
+
+  /* Fallback */
+  if (variant == nullptr)
+    goto out;
+
+  g_variant_iter_init (&iter, variant);
+  n = g_variant_iter_n_children (&iter);
+  colors = g_new (GdkRGBA, n);
+
+  i = 0;
+  while (g_variant_iter_next (&iter, "&s", &str)) {
+    if (!gdk_rgba_parse (&colors[i++], str)) {
+      return FALSE;
+    }
+  }
+
+ out:
+  gs_transfer_out_value (result, &colors);
+  if (n_colors)
+    *n_colors = n;
+
+  return TRUE;
+}
+
+/**
+ * terminal_g_settings_get_rgba_palette:
+ * @settings: a #GSettings
+ * @key: a valid key in @settings or type "s"
+ * @n_colors: (allow-none): location to store the number of palette entries, or %nullptr
+ *
+ * Returns: (transfer full):
+ */
+GdkRGBA *
+terminal_g_settings_get_rgba_palette (GSettings  *settings,
+                                      const char *key,
+                                      gsize      *n_colors)
+{
+  return (GdkRGBA*)g_settings_get_mapped (settings, key,
+					  as_to_rgba_palette,
+					  n_colors);
+}
+
+void
+terminal_g_settings_set_rgba_palette (GSettings      *settings,
+                                      const char     *key,
+                                      const GdkRGBA  *colors,
+                                      gsize           n_colors)
+{
+  gs_strfreev char **strv;
+  gsize i;
+
+  strv = g_new (char *, n_colors + 1);
+  for (i = 0; i < n_colors; ++i)
+    strv[i] = gdk_rgba_to_string (&colors[i]);
+  strv[n_colors] = nullptr;
+
+  g_settings_set (settings, key, "^as", strv);
+}
+
+static void
+mnemonic_label_set_sensitive_cb (GtkWidget *widget,
+                                 GParamSpec *pspec,
+                                 GtkWidget *label)
+{
+  gtk_widget_set_sensitive (label, gtk_widget_get_sensitive (widget));
+}
+
+/**
+ * terminal_util_bind_mnemonic_label_sensitivity:
+ * @container: a #GtkContainer
+ */
+void
+terminal_util_bind_mnemonic_label_sensitivity (GtkWidget *widget)
+{
+  GList *list, *l;
+
+  list = gtk_widget_list_mnemonic_labels (widget);
+  for (l = list; l != nullptr; l = l->next) {
+    GtkWidget *label = (GtkWidget*)l->data;
+
+    if (gtk_widget_is_ancestor (label, widget))
+      continue;
+
+#if 0
+    g_print ("Widget %s has mnemonic label %s\n",
+             gtk_buildable_get_name (GTK_BUILDABLE (widget)),
+             gtk_buildable_get_name (GTK_BUILDABLE (label)));
+#endif
+
+    mnemonic_label_set_sensitive_cb (widget, nullptr, label);
+    g_signal_connect (widget, "notify::sensitive",
+                      G_CALLBACK (mnemonic_label_set_sensitive_cb),
+                      label);
+  }
+  g_list_free (list);
+
+  if (GTK_IS_CONTAINER (widget))
+    gtk_container_foreach (GTK_CONTAINER (widget),
+                           /* See #96 for double casting. */
+                           (GtkCallback) (GCallback) terminal_util_bind_mnemonic_label_sensitivity,
+                           nullptr);
+}
+
+/*
+ * "1234567", "'", 3 -> "1'234'567"
+ */
+static char *
+add_separators (const char *in, const char *sep, int groupby)
+{
+  int inlen, outlen, seplen, firstgrouplen;
+  char *out, *ret;
+
+  if (in[0] == '\0')
+    return g_strdup("");
+
+  inlen = strlen(in);
+  seplen = strlen(sep);
+  outlen = inlen + (inlen - 1) / groupby * seplen;
+  ret = out = (char*)g_malloc(outlen + 1);
+
+  firstgrouplen = (inlen - 1) % groupby + 1;
+  memcpy(out, in, firstgrouplen);
+  in += firstgrouplen;
+  out += firstgrouplen;
+
+  while (*in != '\0') {
+    memcpy(out, sep, seplen);
+    out += seplen;
+    memcpy(out, in, groupby);
+    in += groupby;
+    out += groupby;
+  }
+
+  g_assert(out - ret == outlen);
+  *out = '\0';
+  return ret;
+}
+
+/**
+ * terminal_util_number_info:
+ * @str: a dec or hex number as string
+ *
+ * Returns: (transfer full): Useful info about @str, or %nullptr if it's too large
+ */
+char *
+terminal_util_number_info (const char *str)
+{
+  gs_free char *decstr = nullptr;
+  gs_free char *hextmp = nullptr;
+  gs_free char *hexstr = nullptr;
+  gs_free char *magnitudestr = nullptr;
+  gboolean exact = TRUE;
+  gboolean hex = FALSE;
+  const char *thousep;
+
+  /* Deliberately not handle octal */
+  if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
+    str += 2;
+    hex = TRUE;
+  }
+
+  errno = 0;
+  char* end;
+  gint64 num = g_ascii_strtoull(str, &end, hex ? 16 : 10);
+  if (errno || str == end || num == -1)
+    return nullptr;
+
+  /* No use in dec-hex conversion for so small numbers */
+  if (num < 10) {
+    return nullptr;
+  }
+
+  /* Group the decimal digits */
+  thousep = nl_langinfo(THOUSEP);
+  if (thousep[0] != '\0') {
+    /* If thousep is nonempty, use printf's magic which can handle
+       more complex separating logics, e.g. 2+2+2+3 for some locales */
+    decstr = g_strdup_printf("%'" G_GINT64_FORMAT, num);
+  } else {
+    /* If, however, thousep is empty, override it with a space so that we
+       do always group the digits (that's the whole point of this feature;
+       the choice of space guarantees not conflicting with the decimal separator) */
+    gs_free char *tmp = g_strdup_printf("%" G_GINT64_FORMAT, num);
+    thousep = " ";
+    decstr = add_separators(tmp, thousep, 3);
+  }
+
+  /* Group the hex digits by 4 using the same nonempty separator */
+  hextmp = g_strdup_printf("%" G_GINT64_MODIFIER "x", (guint64)(num));
+  hexstr = add_separators(hextmp, thousep, 4);
+
+  /* Find out the human-readable magnitude, e.g. 15.99 Mi */
+  if (num >= 1024) {
+    int power = 0;
+    while (num >= 1024 * 1024) {
+      power++;
+      if (num % 1024 != 0)
+        exact = FALSE;
+      num /= 1024;
+    }
+    /* Show 2 fraction digits, always rounding downwards. Printf rounds floats to the nearest representable value,
+       so do the calculation with integers until we get 100-fold the desired value, and then switch to float. */
+    if (100 * num % 1024 != 0)
+      exact = FALSE;
+    num = 100 * num / 1024;
+    magnitudestr = g_strdup_printf(" %s %.2f %ci", exact ? "=" : "≈", (double) num / 100, "KMGTPE"[power]);
+  } else {
+    magnitudestr = g_strdup("");
+  }
+
+  return g_strdup_printf(hex ? "0x%2$s = %1$s%3$s" : "%s = 0x%s%s", decstr, hexstr, magnitudestr);
+}
+
+/**
+ * terminal_util_timestamp_info:
+ * @str: a dec or hex number as string
+ *
+ * Returns: (transfer full): Formatted localtime if @str is decimal and looks like a timestamp, or %nullptr
+ */
+char *
+terminal_util_timestamp_info (const char *str)
+{
+  /* Bail out on hex numbers */
+  if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
+    return nullptr;
+  }
+
+  /* Deliberately not handle octal */
+  errno = 0;
+  char* end;
+  gint64 num = g_ascii_strtoull (str, &end, 10);
+  if (errno || end == str || num == -1)
+    return nullptr;
+
+  /* Java uses Unix time in milliseconds. */
+  if (num >= 1000000000000 && num <= 1999999999999)
+    num /= 1000;
+
+  /* Fun: use inclusive interval so you can right-click on these numbers
+   * and check the human-readable time in gnome-terminal.
+   * (They're Sep 9 2001 and May 18 2033 by the way.) */
+  if (num < 1000000000 || num > 1999999999)
+    return nullptr;
+
+  gs_unref_date_time GDateTime* date = g_date_time_new_from_unix_local (num);
+  if (date == nullptr)
+    return nullptr;
+
+  return g_date_time_format(date, "%c");
+}
+
+/**
+ * terminal_util_uri_fixup:
+ * @uri: The URI to verify and maybe fixup
+ * @error: a #GError that is returned in case of errors
+ *
+ * Checks if gnome-terminal should attempt to handle the given URI,
+ * and rewrites if necessary.
+ *
+ * Currently URIs of "file://some-other-host/..." are refused because
+ * GIO (e.g. gtk_show_uri()) silently strips off the remote hostname
+ * and opens the local counterpart which is incorrect and misleading.
+ *
+ * Furthermore, once the hostname is verified, it is stripped off to
+ * avoid potential confusion around short hostname vs. fqdn, and to
+ * work around bug 781800 (LibreOffice bug 107461).
+ *
+ * Returns: The possibly rewritten URI if gnome-terminal should attempt
+ *   to handle it, nullptr if it should refuse to handle.
+ */
+char *
+terminal_util_uri_fixup (const char *uri,
+                         GError **error)
+{
+  gs_free char *filename;
+  gs_free char *hostname;
+
+  filename = g_filename_from_uri (uri, &hostname, nullptr);
+  if (filename != nullptr &&
+      hostname != nullptr &&
+      hostname[0] != '\0') {
+    /* "file" scheme and nonempty hostname */
+    if (g_ascii_strcasecmp (hostname, "localhost") == 0 ||
+        g_ascii_strcasecmp (hostname, g_get_host_name()) == 0) {
+      /* hostname corresponds to localhost */
+      char const *slash1, *slash2, *slash3;
+
+      /* We shouldn't enter this branch in case of URIs like
+       * "file:/etc/passwd", but just in case we do, or encounter
+       * something else unexpected, leave the URI unchanged. */
+      slash1 = strchr(uri, '/');
+      if (slash1 == nullptr)
+        return g_strdup (uri);
+
+      slash2 = slash1 + 1;
+      if (*slash2 != '/')
+        return g_strdup (uri);
+
+      slash3 = strchr(slash2 + 1, '/');
+      if (slash3 == nullptr)
+        return g_strdup (uri);
+
+      return g_strdup_printf("%.*s%s",
+                             (int) (slash2 + 1 - uri),
+                             uri,
+                             slash3);
+    } else {
+      /* hostname refers to another host (e.g. the OSC 8 escape sequence
+       * was correctly emitted by a utility inside an ssh session) */
+      g_set_error_literal (error,
+                           G_IO_ERROR,
+                           G_IO_ERROR_NOT_SUPPORTED,
+                         _("“file” scheme with remote hostname not supported"));
+      return nullptr;
+    }
+  } else {
+    /* "file" scheme without hostname, or some other scheme */
+    return g_strdup (uri);
+  }
+}
+
+/**
+ * terminal_util_hyperlink_uri_label:
+ * @uri: a URI
+ *
+ * Formats @uri to be displayed in a tooltip.
+ * Performs URI-decoding and converts IDN hostname to UTF-8.
+ *
+ * Returns: (transfer full): The human readable URI as plain text
+ */
+char *terminal_util_hyperlink_uri_label (const char *uri)
+{
+  gs_free char *unesc = nullptr;
+  gboolean replace_hostname;
+
+  if (uri == nullptr)
+    return nullptr;
+
+  unesc = g_uri_unescape_string(uri, nullptr);
+  if (unesc == nullptr)
+    unesc = g_strdup(uri);
+
+  if (g_ascii_strncasecmp(unesc, "ftp://", 6) == 0 ||
+      g_ascii_strncasecmp(unesc, "http://", 7) == 0 ||
+      g_ascii_strncasecmp(unesc, "https://", 8) == 0) {
+    gs_free char *unidn = nullptr;
+    char *hostname = strchr(unesc, '/') + 2;
+    char *hostname_end = strchrnul(hostname, '/');
+    char save = *hostname_end;
+    *hostname_end = '\0';
+    unidn = g_hostname_to_unicode(hostname);
+    replace_hostname = unidn != nullptr && g_ascii_strcasecmp(unidn, hostname) != 0;
+    *hostname_end = save;
+    if (replace_hostname) {
+      char *new_unesc = g_strdup_printf("%.*s%s%s",
+                                        (int) (hostname - unesc),
+                                        unesc,
+                                        unidn,
+                                        hostname_end);
+      g_free(unesc);
+      unesc = new_unesc;
+    }
+  }
+
+  return g_utf8_make_valid (unesc, -1);
+}
+
+#define TERMINAL_CACHE_DIR                 "gnome-terminal"
+#define TERMINAL_PRINT_SETTINGS_FILENAME   "print-settings.ini"
+#define TERMINAL_PRINT_SETTINGS_GROUP_NAME "Print Settings"
+#define TERMINAL_PAGE_SETUP_GROUP_NAME     "Page Setup"
+
+#define KEYFILE_FLAGS_FOR_LOAD GKeyFileFlags(G_KEY_FILE_NONE)
+#define KEYFILE_FLAGS_FOR_SAVE GKeyFileFlags(G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS)
+
+static char *
+get_cache_dir (void)
+{
+  return g_build_filename (g_get_user_cache_dir (), TERMINAL_CACHE_DIR, nullptr);
+}
+
+static gboolean
+ensure_cache_dir (void)
+{
+  gs_free char *cache_dir;
+  int r;
+
+  cache_dir = get_cache_dir ();
+  errno = 0;
+  r = g_mkdir_with_parents (cache_dir, 0700);
+  if (r == -1 && errno != EEXIST) {
+    auto const errsv = errno;
+    g_printerr ("Failed to create cache dir: %s\n", g_strerror(errsv));
+  }
+  return r == 0;
+}
+
+static char *
+get_cache_filename (const char *filename)
+{
+  gs_free char *cache_dir = get_cache_dir ();
+  return g_build_filename (cache_dir, filename, nullptr);
+}
+
+static GKeyFile *
+load_cache_keyfile (const char *filename,
+                    GKeyFileFlags flags,
+                    gboolean ignore_error)
+{
+  gs_free char *path;
+  GKeyFile *keyfile;
+
+  path = get_cache_filename (filename);
+  keyfile = g_key_file_new ();
+  if (g_key_file_load_from_file (keyfile, path, flags, nullptr) || ignore_error)
+    return keyfile;
+
+  g_key_file_unref (keyfile);
+  return nullptr;
+}
+
+static void
+save_cache_keyfile (GKeyFile *keyfile,
+                    const char *filename)
+{
+  gs_free char *path = nullptr;
+  gs_free char *data = nullptr;
+  gsize len = 0;
+
+  if (!ensure_cache_dir ())
+    return;
+
+  data = g_key_file_to_data (keyfile, &len, nullptr);
+  if (data == nullptr || len == 0)
+    return;
+
+  path = get_cache_filename (filename);
+
+  /* Ignore errors */
+  GError *err = nullptr;
+  if (!g_file_set_contents (path, data, len, &err)) {
+    g_printerr ("Error saving print settings: %s\n", err->message);
+    g_error_free (err);
+  }
+}
+
+static void
+keyfile_remove_keys (GKeyFile *keyfile,
+                     const char *group_name,
+                     ...)
+{
+  va_list args;
+  const char *key;
+
+  va_start (args, group_name);
+  while ((key = va_arg (args, const char *)) != nullptr) {
+    g_key_file_remove_key (keyfile, group_name, key, nullptr);
+  }
+  va_end (args);
+}
+
+/**
+ * terminal_util_load_print_settings:
+ *
+ * Loads the saved print settings, if any.
+ */
+void
+terminal_util_load_print_settings (GtkPrintSettings **settings,
+                                   GtkPageSetup **page_setup)
+{
+  gs_unref_key_file GKeyFile *keyfile = load_cache_keyfile (TERMINAL_PRINT_SETTINGS_FILENAME,
+                                                            KEYFILE_FLAGS_FOR_LOAD,
+                                                            FALSE);
+  if (keyfile == nullptr) {
+    *settings = nullptr;
+    *page_setup = nullptr;
+    return;
+  }
+
+  /* Ignore errors */
+  *settings = gtk_print_settings_new_from_key_file (keyfile,
+                                                    TERMINAL_PRINT_SETTINGS_GROUP_NAME,
+                                                    nullptr);
+  *page_setup = gtk_page_setup_new_from_key_file (keyfile,
+                                                  TERMINAL_PAGE_SETUP_GROUP_NAME,
+                                                  nullptr);
+}
+
+/**
+ * terminal_util_save_print_settings:
+ * @settings: (allow-none): a #GtkPrintSettings
+ * @page_setup: (allow-none): a #GtkPageSetup
+ *
+ * Saves the print settings.
+ */
+void
+terminal_util_save_print_settings (GtkPrintSettings *settings,
+                                   GtkPageSetup *page_setup)
+{
+  gs_unref_key_file GKeyFile *keyfile = nullptr;
+
+  keyfile = load_cache_keyfile (TERMINAL_PRINT_SETTINGS_FILENAME,
+                                KEYFILE_FLAGS_FOR_SAVE,
+                                TRUE);
+  g_assert (keyfile != nullptr);
+
+  if (settings != nullptr)
+    gtk_print_settings_to_key_file (settings, keyfile,
+                                    TERMINAL_PRINT_SETTINGS_GROUP_NAME);
+
+  /* Some keys are not desirable to persist; remove these.
+   * This list comes from evince.
+   */
+  keyfile_remove_keys (keyfile,
+                       TERMINAL_PRINT_SETTINGS_GROUP_NAME,
+                       GTK_PRINT_SETTINGS_COLLATE,
+                       GTK_PRINT_SETTINGS_NUMBER_UP,
+                       GTK_PRINT_SETTINGS_N_COPIES,
+                       GTK_PRINT_SETTINGS_OUTPUT_URI,
+                       GTK_PRINT_SETTINGS_PAGE_RANGES,
+                       GTK_PRINT_SETTINGS_PAGE_SET,
+                       GTK_PRINT_SETTINGS_PRINT_PAGES,
+                       GTK_PRINT_SETTINGS_REVERSE,
+                       GTK_PRINT_SETTINGS_SCALE,
+                       nullptr);
+
+  if (page_setup != nullptr)
+    gtk_page_setup_to_key_file (page_setup, keyfile,
+                                TERMINAL_PAGE_SETUP_GROUP_NAME);
+
+  /* Some keys are not desirable to persist; remove these.
+   * This list comes from evince.
+   */
+  keyfile_remove_keys (keyfile,
+                       TERMINAL_PAGE_SETUP_GROUP_NAME,
+                       "page-setup-orientation",
+                       "page-setup-margin-bottom",
+                       "page-setup-margin-left",
+                       "page-setup-margin-right",
+                       "page-setup-margin-top",
+                       nullptr);
+
+  save_cache_keyfile (keyfile, TERMINAL_PRINT_SETTINGS_FILENAME);
+}
+
+/*
+ * terminal_util_translate_encoding:
+ * @encoding: the encoding name
+ *
+ * Translates old encoding name to the one supported by ICU, or
+ * to %nullptr if the encoding is not known to ICU.
+ *
+ * Returns: (transfer none): the translated encoding, or %nullptr if
+ *   not translation was possible.
+ */
+const char*
+terminal_util_translate_encoding (const char *encoding)
+{
+  G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
+  if (vte_get_encoding_supported (encoding))
+    return encoding;
+  G_GNUC_END_IGNORE_DEPRECATIONS;
+
+  /* ICU knows (or has aliases for) most of the old names, except the following */
+  struct {
+    const char *name;
+    const char *replacement;
+  } translations[] = {
+    { "ARMSCII-8",      nullptr           }, /* apparently not supported by ICU */
+    { "GEORGIAN-PS",    nullptr           }, /* no idea which charset this even is */
+    { "ISO-IR-111",     nullptr           }, /* ISO-IR-111 refers to ECMA-94, but that
+                                           * standard does not contain cyrillic letters.
+                                           * ECMA-94 refers to ECMA-113 (ISO-IR-144),
+                                           * whose assignment differs greatly from ISO-IR-111,
+                                           * so it cannot be that either.
+                                           */
+    /* All the MAC_* charsets appear to be unknown to even glib iconv, so
+     * why did we have them in our list in the first place?
+     */
+    { "MAC_DEVANAGARI", nullptr           }, /* apparently not supported by ICU */
+    { "MAC_FARSI",      nullptr           }, /* apparently not supported by ICU */
+    { "MAC_GREEK",      "x-MacGreek"   },
+    { "MAC_GUJARATI",   nullptr           }, /* apparently not supported by ICU */
+    { "MAC_GURMUKHI",   nullptr           }, /* apparently not supported by ICU */
+    { "MAC_ICELANDIC",  nullptr           }, /* apparently not supported by ICU */
+    { "MAC_ROMANIAN",   "x-macroman"   }, /* not sure this is the right one */
+    { "MAC_TURKISH",    "x-MacTurkish" },
+    { "MAC_UKRAINIAN",  "x-MacUkraine" },
+
+    { "TCVN",           nullptr           }, /* apparently not supported by ICU */
+    { "UHC",            "cp949"        },
+    { "VISCII",         nullptr           }, /* apparently not supported by ICU */
+
+    /* ISO-2022-* are known to ICU, but they simply cannot work in vte as
+     * I/O encoding, so don't even try.
+     */
+    { "ISO-2022-JP",    nullptr           },
+    { "ISO-2022-KR",    nullptr           },
+  };
+
+  const char *replacement = nullptr;
+  for (guint i = 0; i < G_N_ELEMENTS (translations); ++i) {
+    if (g_str_equal (encoding, translations[i].name)) {
+      replacement = translations[i].replacement;
+      break;
+    }
+  }
+
+  return replacement;
+}
+
+/* BEGIN code copied from glib
+ *
+ * Copyright (C) 1995-1998  Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * Code originally under LGPL2+; used and modified here under GPL3+
+ * Changes:
+ *   Remove win32 support.
+ *   Make @program nullable.
+ *   Use @path instead of getenv("PATH").
+ *   Use strchrnul
+ */
+
+/**
+ * terminal_util_find_program_in_path:
+ * @path: (type filename) (nullable): the search path (delimited by G_SEARCHPATH_SEPARATOR)
+ * @program: (type filename) (nullable): the programme to find in @path
+ *
+ * Like g_find_program_in_path(), but uses @path instead of the
+ * PATH environment variable as the search path.
+ *
+ * Returns: (type filename) (transfer full) (nullable): a newly allocated
+ *  string containing the full path to @program, or %nullptr if @program
+ *  could not be found in @path.
+ */
+char *
+terminal_util_find_program_in_path (const char *path,
+                                    const char *program)
+{
+  const gchar *p;
+  gchar *name, *freeme;
+  gsize len;
+  gsize pathlen;
+
+  if (program == nullptr)
+    return nullptr;
+
+  /* If it is an absolute path, or a relative path including subdirectories,
+   * don't look in PATH.
+   */
+  if (g_path_is_absolute (program)
+      || strchr (program, G_DIR_SEPARATOR) != nullptr
+      )
+    {
+      if (g_file_test (program, G_FILE_TEST_IS_EXECUTABLE) &&
+	  !g_file_test (program, G_FILE_TEST_IS_DIR))
+        return g_strdup (program);
+      else
+        return nullptr;
+    }
+
+  if (path == nullptr)
+    {
+      /* There is no 'PATH' in the environment.  The default
+       * search path in GNU libc is the current directory followed by
+       * the path 'confstr' returns for '_CS_PATH'.
+       */
+
+      /* In GLib we put . last, for security, and don't use the
+       * unportable confstr(); UNIX98 does not actually specify
+       * what to search if PATH is unset. POSIX may, dunno.
+       */
+
+      path = "/bin:/usr/bin:.";
+    }
+
+  len = strlen (program) + 1;
+  pathlen = strlen (path);
+  freeme = name = (char*)g_malloc (pathlen + len + 1);
+
+  /* Copy the file name at the top, including '\0'  */
+  memcpy (name + pathlen + 1, program, len);
+  name = name + pathlen;
+  /* And add the slash before the filename  */
+  *name = G_DIR_SEPARATOR;
+
+  p = path;
+  do
+    {
+      char *startp;
+
+      path = p;
+      p = strchrnul (path, G_SEARCHPATH_SEPARATOR);
+
+      if (p == path)
+        /* Two adjacent colons, or a colon at the beginning or the end
+         * of 'PATH' means to search the current directory.
+         */
+        startp = name + 1;
+      else
+        startp = (char*)memcpy (name - (p - path), path, p - path);
+
+      if (g_file_test (startp, G_FILE_TEST_IS_EXECUTABLE) &&
+	  !g_file_test (startp, G_FILE_TEST_IS_DIR))
+        {
+          gchar *ret;
+          ret = g_strdup (startp);
+          g_free (freeme);
+          return ret;
+        }
+    }
+  while (*p++ != '\0');
+
+  g_free (freeme);
+  return nullptr;
+}
+
+/* END code copied from glib */
+
+/*
+ * terminal_util_check_envv:
+ * @strv:
+ *
+ * Validates that each element is of the form 'KEY=VALUE'.
+ */
+gboolean
+terminal_util_check_envv(char const* const* strv)
+{
+  if (!strv)
+    return TRUE;
+
+  for (int i = 0; strv[i]; ++i) {
+          const char *str = strv[i];
+          const char *equal = strchr(str, '=');
+          if (equal == nullptr || equal == str)
+                  return FALSE;
+  }
+
+  return TRUE;
+}
+
+char**
+terminal_util_get_desktops(void)
+{
+  auto const desktop = g_getenv("XDG_CURRENT_DESKTOP");
+  if (!desktop)
+    return nullptr;
+
+  return g_strsplit(desktop, G_SEARCHPATH_SEPARATOR_S, -1);
+}
+
+#define XTE_CONFIG_DIRNAME  "xdg-terminals"
+#define XTE_CONFIG_FILENAME "xdg-terminals.list"
+
+#define NEWLINE '\n'
+#define DOT_DESKTOP ".desktop"
+#define TERMINAL_DESKTOP_FILENAME TERMINAL_APPLICATION_ID DOT_DESKTOP
+
+static bool
+xte_data_check_one(char const* file,
+                   bool full)
+{
+  if (!g_file_test(file, G_FILE_TEST_EXISTS)) {
+    _terminal_debug_print(TERMINAL_DEBUG_DEFAULT,
+                          "Desktop file \"%s\" does not exist.\n",
+                          file);
+    return false;
+  }
+
+  if (!full)
+    return true;
+
+  gs_free_error GError* error = nullptr;
+  gs_unref_key_file auto kf = g_key_file_new();
+  if (!g_key_file_load_from_file(kf,
+                                 file,
+                                 GKeyFileFlags(G_KEY_FILE_NONE),
+                                 &error)) {
+    _terminal_debug_print(TERMINAL_DEBUG_DEFAULT,
+                          "Failed to load  \"%s\" as keyfile: %s\n",
+                          file, error->message);
+
+    return false;
+  }
+
+  if (!g_key_file_has_group(kf, G_KEY_FILE_DESKTOP_GROUP)) {
+    _terminal_debug_print(TERMINAL_DEBUG_DEFAULT,
+                          "Keyfile file \"%s\" is not a desktop file.\n",
+                          file);
+    return false;
+  }
+
+  // As per the XDG desktop entry spec, the (optional) TryExec key contains
+  // the name of an executable that can be used to determine if the programme
+  // is actually present.
+  gs_free auto try_exec = g_key_file_get_string(kf,
+                                                G_KEY_FILE_DESKTOP_GROUP,
+                                                G_KEY_FILE_DESKTOP_KEY_TRY_EXEC,
+                                                nullptr);
+  if (try_exec && try_exec[0]) {
+    _terminal_debug_print(TERMINAL_DEBUG_DEFAULT,
+                          "Desktop file \"%s\" has no TryExec field.\n",
+                          file);
+
+    // TryExec may be an abolute path, or be searched in $PATH
+    gs_free char* exec_path = nullptr;
+    if (g_path_is_absolute(try_exec))
+      exec_path = g_strdup(try_exec);
+    else
+      exec_path = g_find_program_in_path(try_exec);
+
+    auto const exists = exec_path != nullptr &&
+      g_file_test(exec_path, GFileTest(G_FILE_TEST_IS_EXECUTABLE));
+
+    _terminal_debug_print(TERMINAL_DEBUG_DEFAULT,
+                          "Desktop file \"%s\" is %sinstalled (TryExec).\n",
+                          file, exists ? "" : "not ");
+
+    if (!exists)
+      return false;
+  } else {
+    // TryExec is not present. We could fall back to parsing the Exec
+    // key and look if its first argument points to an executable that
+    // exists on the system, but that may also fail if the desktop file
+    // is DBusActivatable=true in which case we would need to find
+    // out if the D-Bus service corresponding to the name of the desktop
+    // file (without the .desktop extension) is activatable.
+  }
+
+  return true;
+}
+
+static bool
+xte_data_check(char const* name,
+               bool full)
+{
+  gs_free auto user_path = g_build_filename(g_get_user_data_dir(),
+                                            XTE_CONFIG_DIRNAME,
+                                            name,
+                                            nullptr);
+  if (xte_data_check_one(user_path, full))
+    return true;
+
+  gs_free auto local_path = g_build_filename(TERM_PREFIX, "local", "share",
+                                             XTE_CONFIG_DIRNAME,
+                                             name,
+                                             nullptr);
+  if (xte_data_check_one(local_path, full))
+    return true;
+
+  gs_free auto sys_path = g_build_filename(TERM_DATADIR,
+                                           XTE_CONFIG_DIRNAME,
+                                           name,
+                                           nullptr);
+  if (xte_data_check_one(sys_path, full))
+    return true;
+
+  return false;
+}
+
+static bool
+xte_data_ensure(void)
+{
+  if (xte_data_check(TERMINAL_DESKTOP_FILENAME, false))
+    return true;
+
+  // If we get here, there wasn't a desktop file in any of the paths. Install
+  // a symlink to the system-installed desktop file into the user path.
+
+  gs_free auto user_dir = g_build_filename(g_get_user_data_dir(),
+                                           XTE_CONFIG_DIRNAME,
+                                           nullptr);
+  if (g_mkdir_with_parents(user_dir, 0700) != 0 &&
+      errno != EEXIST) {
+    auto const errsv = errno;
+    _terminal_debug_print(TERMINAL_DEBUG_DEFAULT,
+                          "Failed to create directory %s: %s\n",
+                          user_dir, g_strerror(errsv));
+    return false;
+  }
+
+  gs_free auto link_path = g_build_filename(user_dir,
+                                            TERMINAL_DESKTOP_FILENAME,
+                                            nullptr);
+  gs_free auto target_path = g_build_filename(TERM_DATADIR,
+                                              "applications",
+                                              TERMINAL_DESKTOP_FILENAME,
+                                              nullptr);
+
+  auto const r = symlink(target_path, link_path);
+  if (r != -1) {
+    _terminal_debug_print(TERMINAL_DEBUG_DEFAULT,
+                          "Installed symlink %s -> %s\n",
+                          link_path, target_path);
+
+  } else {
+    auto const errsv = errno;
+    _terminal_debug_print(TERMINAL_DEBUG_DEFAULT,
+                          "Failed to create symlink %s: %s\n",
+                          link_path, g_strerror(errsv));
+  }
+
+  return r != -1;
+}
+
+static char**
+xte_config_read(char const* path,
+                GError** error)
+{
+  gs_close_fd auto fd = open(path, O_RDONLY | O_NONBLOCK | O_CLOEXEC);
+  if (fd == -1)
+    return nullptr;
+
+  // This is a small config file, so shouldn't be any bigger than this.
+  // If it is bigger, we'll discard the rest. That's why we're not using
+  // g_file_get_contents() here.
+  char buf[8192];
+  auto r = ssize_t{};
+  do {
+    r = read(fd, buf, sizeof(buf) - 1); // reserve one byte in buf
+  } while (r == -1 && errno == EINTR);
+  if (r < 0)
+    return nullptr;
+
+  buf[r] = '\0'; // NUL terminator; note that r < sizeof(buf)
+
+  auto lines = g_strsplit_set(buf, "\r\n", -1);
+  if (!lines)
+    return nullptr;
+
+  for (auto i = 0; lines[i]; ++i)
+    lines[i] = g_strstrip(lines[i]);
+
+  return lines;
+}
+
+static bool
+xte_config_rewrite(char const* path)
+{
+  gs_free_gstring auto str = g_string_sized_new(1024);
+  g_string_append(str, TERMINAL_DESKTOP_FILENAME);
+  g_string_append_c(str, NEWLINE);
+
+  gs_strfreev auto lines = xte_config_read(path, nullptr);
+  if (lines) {
+    for (auto i = 0; lines[i]; ++i) {
+      if (lines[i][0] == '\0')
+        continue;
+      if (strcmp(lines[i], TERMINAL_DESKTOP_FILENAME) == 0)
+        continue;
+
+      g_string_append(str, lines[i]);
+      g_string_append_c(str, NEWLINE);
+    }
+  }
+
+  gs_free_error GError* error = nullptr;
+  auto const r = g_file_set_contents(path, str->str, str->len, &error);
+  if (!r) {
+    _terminal_debug_print(TERMINAL_DEBUG_DEFAULT,
+                          "Failed to rewrite XTE config %s: %s\n",
+                          path, error->message);
+  }
+
+  return r;
+}
+
+static void
+xte_config_rewrite(void)
+{
+  auto const user_dir = g_get_user_config_dir();
+  if (g_mkdir_with_parents(user_dir, 0700) != 0 &&
+      errno != EEXIST) {
+    auto const errsv = errno;
+    _terminal_debug_print(TERMINAL_DEBUG_DEFAULT,
+                          "Failed to create directory %s: %s\n",
+                          user_dir, g_strerror(errsv));
+   // Nothing to do if we can't even create the directory
+    return;
+  }
+
+  // Install as default for all current desktops
+  gs_strfreev auto desktops = terminal_util_get_desktops();
+  if (desktops) {
+    for (auto i = 0; desktops[i]; ++i) {
+      gs_free auto name = g_strdup_printf("%s-" XTE_CONFIG_FILENAME,
+                                          desktops[i]);
+      gs_free auto path = g_build_filename(user_dir, name, nullptr);
+
+      xte_config_rewrite(path);
+    }
+  }
+
+  // Install as non-desktop specific default too
+  gs_free auto path = g_build_filename(user_dir, XTE_CONFIG_FILENAME, nullptr);
+  xte_config_rewrite(path);
+}
+
+static bool
+xte_config_is_foreign(char const* name)
+{
+  return !g_str_equal(name, TERMINAL_DESKTOP_FILENAME);
+}
+
+static char*
+xte_config_get_default(char const* path)
+{
+  gs_strfreev auto lines = xte_config_read(path, nullptr);
+  if (!lines)
+    return nullptr;
+
+  // A terminal is the default if it's the first non-comment line in the file
+  for (auto i = 0; lines[i]; ++i) {
+    auto const line = lines[i];
+    if (!line[0] || line[0] == '#')
+      continue;
+
+    // If a foreign terminal is default, check whether it is actually installed.
+    // (We always ensure our own desktop file exists.)
+    if (xte_config_is_foreign(line) &&
+        !xte_data_check(line, true)) {
+      _terminal_debug_print(TERMINAL_DEBUG_DEFAULT,
+                            "Default entry \"%s\" from config \"%s\" is not installed, skipping.\n",
+                            line, path);
+      return nullptr;
+    }
+
+    return g_strdup(line);
+  }
+
+  return nullptr;
+}
+
+static char*
+xte_config_get_default(void)
+{
+  auto const user_dir = g_get_user_config_dir();
+  gs_strfreev auto desktops = terminal_util_get_desktops();
+  if (desktops) {
+    for (auto i = 0; desktops[i]; ++i) {
+      gs_free auto name = g_strdup_printf("%s-" XTE_CONFIG_FILENAME,
+                                          desktops[i]);
+      gs_free auto path = g_build_filename(user_dir, name, nullptr);
+      if (auto term = xte_config_get_default(path))
+        return term;
+    }
+  }
+
+  gs_free auto user_path = g_build_filename(user_dir, XTE_CONFIG_FILENAME, nullptr);
+  if (auto term = xte_config_get_default(user_path))
+    return term;
+
+  if (desktops) {
+    for (auto i = 0; desktops[i]; ++i) {
+      gs_free auto name = g_strdup_printf("%s-" XTE_CONFIG_FILENAME,
+                                          desktops[i]);
+      gs_free auto path = g_build_filename("/etc/xdg", name, nullptr);
+      if (auto term = xte_config_get_default(path))
+        return term;
+    }
+  }
+
+  gs_free auto sys_path = g_build_filename("/etc/xdg", XTE_CONFIG_FILENAME, nullptr);
+  if (auto term = xte_config_get_default(sys_path))
+    return term;
+
+  return nullptr;
+}
+
+static bool
+xte_config_is_default(bool* set = nullptr)
+{
+  gs_free auto term = xte_config_get_default();
+
+  auto const is_default = term && g_str_equal(term, TERMINAL_DESKTOP_FILENAME);
+  if (set)
+    *set = term != nullptr;
+  return is_default;
+}
+
+gboolean
+terminal_util_is_default_terminal(void)
+{
+  auto set = false;
+  auto const is_default = xte_config_is_default(&set);
+  if (!set) {
+    // No terminal is default yet, so we claim the default.
+    _terminal_debug_print(TERMINAL_DEBUG_DEFAULT,
+                          "No default terminal, claiming default.\n");
+    return terminal_util_make_default_terminal();
+  }
+
+  if (is_default) {
+    // If we're the default terminal, ensure our desktop file is installed
+    // in the right location.
+    xte_data_ensure();
+  }
+
+  return is_default;
+}
+
+gboolean
+terminal_util_make_default_terminal(void)
+{
+  xte_config_rewrite();
+  xte_data_ensure();
+
+  return xte_config_is_default();
+}