initial

1 files changed, 614 insertions, 0 deletions

diff --git a/src/terminal-encoding.c b/src/terminal-encoding.c
new file mode 100644
index 0000000..25d343b
--- /dev/null
+++ b/src/terminal-encoding.c
@@ -0,0 +1,614 @@
+/*
+ * Copyright © 2002 Red Hat, Inc.
+ * 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 <gtk/gtk.h>
+
+#include "terminal-app.h"
+#include "terminal-debug.h"
+#include "terminal-encoding.h"
+#include "terminal-intl.h"
+#include "terminal-profile.h"
+#include "terminal-util.h"
+
+/* Overview
+ *
+ * There's a list of character sets stored in mateconf, indicating
+ * which encodings to display in the encoding menu.
+ * 
+ * We have a pre-canned list of available encodings
+ * (hardcoded in the table below) that can be added to
+ * the encoding menu, and to give a human-readable name
+ * to certain encodings.
+ *
+ * If the mateconf list contains an encoding not in the
+ * predetermined table, then that encoding is
+ * labeled "user defined" but still appears in the menu.
+ */
+
+static const struct {
+  const char *charset;
+  const char *name;
+} encodings[] = {
+  { "ISO-8859-1",	N_("Western") },
+  { "ISO-8859-2",	N_("Central European") },
+  { "ISO-8859-3",	N_("South European") },
+  { "ISO-8859-4",	N_("Baltic") },
+  { "ISO-8859-5",	N_("Cyrillic") },
+  { "ISO-8859-6",	N_("Arabic") },
+  { "ISO-8859-7",	N_("Greek") },
+  { "ISO-8859-8",	N_("Hebrew Visual") },
+  { "ISO-8859-8-I",	N_("Hebrew") },
+  { "ISO-8859-9",	N_("Turkish") },
+  { "ISO-8859-10",	N_("Nordic") },
+  { "ISO-8859-13",	N_("Baltic") },
+  { "ISO-8859-14",	N_("Celtic") },
+  { "ISO-8859-15",	N_("Western") },
+  { "ISO-8859-16",	N_("Romanian") },
+  { "UTF-8",	N_("Unicode") },
+  { "ARMSCII-8",	N_("Armenian") },
+  { "BIG5",	N_("Chinese Traditional") },
+  { "BIG5-HKSCS",	N_("Chinese Traditional") },
+  { "CP866",	N_("Cyrillic/Russian") },
+  { "EUC-JP",	N_("Japanese") },
+  { "EUC-KR",	N_("Korean") },
+  { "EUC-TW",	N_("Chinese Traditional") },
+  { "GB18030",	N_("Chinese Simplified") },
+  { "GB2312",	N_("Chinese Simplified") },
+  { "GBK",	N_("Chinese Simplified") },
+  { "GEORGIAN-PS",	N_("Georgian") },
+  { "IBM850",	N_("Western") },
+  { "IBM852",	N_("Central European") },
+  { "IBM855",	N_("Cyrillic") },
+  { "IBM857",	N_("Turkish") },
+  { "IBM862",	N_("Hebrew") },
+  { "IBM864",	N_("Arabic") },
+  { "ISO-2022-JP",	N_("Japanese") },
+  { "ISO-2022-KR",	N_("Korean") },
+  { "ISO-IR-111",	N_("Cyrillic") },
+  { "KOI8-R",	N_("Cyrillic") },
+  { "KOI8-U",	N_("Cyrillic/Ukrainian") },
+  { "MAC_ARABIC",	N_("Arabic") },
+  { "MAC_CE",	N_("Central European") },
+  { "MAC_CROATIAN",	N_("Croatian") },
+  { "MAC-CYRILLIC",	N_("Cyrillic") },
+  { "MAC_DEVANAGARI",	N_("Hindi") },
+  { "MAC_FARSI",	N_("Persian") },
+  { "MAC_GREEK",	N_("Greek") },
+  { "MAC_GUJARATI",	N_("Gujarati") },
+  { "MAC_GURMUKHI",	N_("Gurmukhi") },
+  { "MAC_HEBREW",	N_("Hebrew") },
+  { "MAC_ICELANDIC",	N_("Icelandic") },
+  { "MAC_ROMAN",	N_("Western") },
+  { "MAC_ROMANIAN",	N_("Romanian") },
+  { "MAC_TURKISH",	N_("Turkish") },
+  { "MAC_UKRAINIAN",	N_("Cyrillic/Ukrainian") },
+  { "SHIFT_JIS",	N_("Japanese") },
+  { "TCVN",	N_("Vietnamese") },
+  { "TIS-620",	N_("Thai") },
+  { "UHC",	N_("Korean") },
+  { "VISCII",	N_("Vietnamese") },
+  { "WINDOWS-1250",	N_("Central European") },
+  { "WINDOWS-1251",	N_("Cyrillic") },
+  { "WINDOWS-1252",	N_("Western") },
+  { "WINDOWS-1253",	N_("Greek") },
+  { "WINDOWS-1254",	N_("Turkish") },
+  { "WINDOWS-1255",	N_("Hebrew") },
+  { "WINDOWS-1256",	N_("Arabic") },
+  { "WINDOWS-1257",	N_("Baltic") },
+  { "WINDOWS-1258",	N_("Vietnamese") },
+#if 0
+  /* These encodings do NOT pass-through ASCII, so are always rejected.
+   * FIXME: why are they in this table; or rather why do we need
+   * the ASCII pass-through requirement?
+   */
+  { "UTF-7",  N_("Unicode") },
+  { "UTF-16", N_("Unicode") },
+  { "UCS-2",  N_("Unicode") },
+  { "UCS-4",  N_("Unicode") },
+  { "JOHAB",  N_("Korean") },
+#endif
+};
+
+typedef struct {
+  GtkWidget *dialog;
+  GtkListStore *base_store;
+  GtkTreeView *available_tree_view;
+  GtkTreeSelection *available_selection;
+  GtkTreeModel *available_model;
+  GtkTreeView *active_tree_view;
+  GtkTreeSelection *active_selection;
+  GtkTreeModel *active_model;
+  GtkWidget *add_button;
+  GtkWidget *remove_button;
+} EncodingDialogData;
+
+static GtkWidget *encoding_dialog = NULL;
+
+TerminalEncoding *
+terminal_encoding_new (const char *charset,
+                       const char *display_name,
+                       gboolean is_custom,
+                       gboolean force_valid)
+{
+  TerminalEncoding *encoding;
+
+  encoding = g_slice_new (TerminalEncoding);
+  encoding->refcount = 1;
+  encoding->id = g_strdup (charset);
+  encoding->name = g_strdup (display_name);
+  encoding->valid = encoding->validity_checked = force_valid;
+  encoding->is_custom = is_custom;
+  encoding->is_active = FALSE;
+
+  return encoding;
+}
+
+TerminalEncoding*
+terminal_encoding_ref (TerminalEncoding *encoding)
+{
+  g_return_val_if_fail (encoding != NULL, NULL);
+
+  encoding->refcount++;
+  return encoding;
+}
+
+void
+terminal_encoding_unref (TerminalEncoding *encoding)
+{
+  if (--encoding->refcount > 0)
+    return;
+
+  g_free (encoding->name);
+  g_free (encoding->id);
+  g_slice_free (TerminalEncoding, encoding);
+}
+
+const char *
+terminal_encoding_get_id (TerminalEncoding *encoding)
+{
+  g_return_val_if_fail (encoding != NULL, NULL);
+
+  return encoding->id;
+}
+
+const char *
+terminal_encoding_get_charset (TerminalEncoding *encoding)
+{
+  g_return_val_if_fail (encoding != NULL, NULL);
+
+  if (strcmp (encoding->id, "current") == 0)
+    {
+      const char *charset;
+
+      g_get_charset (&charset);
+      return charset;
+    }
+
+  return encoding->id;
+}
+
+gboolean
+terminal_encoding_is_valid (TerminalEncoding *encoding)
+{
+  /* All of the printing ASCII characters from space (32) to the tilde (126) */
+  static const char ascii_sample[] =
+      " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
+  char *converted;
+  gsize bytes_read = 0, bytes_written = 0;
+  GError *error = NULL;
+
+  if (encoding->validity_checked)
+    return encoding->valid;
+
+  /* Test that the encoding is a proper superset of ASCII (which naive
+   * apps are going to use anyway) by attempting to validate the text
+   * using the current encoding.  This also flushes out any encodings
+   * which the underlying GIConv implementation can't support.
+   */
+  converted = g_convert (ascii_sample, sizeof (ascii_sample) - 1,
+                         terminal_encoding_get_charset (encoding), "UTF-8",
+                         &bytes_read, &bytes_written, &error);
+
+  /* The encoding is only valid if ASCII passes through cleanly. */
+  encoding->valid = (bytes_read == (sizeof (ascii_sample) - 1)) &&
+                    (converted != NULL) &&
+                    (strcmp (converted, ascii_sample) == 0);
+
+#ifdef MATE_ENABLE_DEBUG
+  _TERMINAL_DEBUG_IF (TERMINAL_DEBUG_ENCODINGS)
+  {
+    if (!encoding->valid)
+      {
+        _terminal_debug_print (TERMINAL_DEBUG_ENCODINGS,
+                               "Rejecting encoding %s as invalid:\n",
+                               terminal_encoding_get_charset (encoding));
+        _terminal_debug_print (TERMINAL_DEBUG_ENCODINGS,
+                               " input  \"%s\"\n",
+                               ascii_sample);
+        _terminal_debug_print (TERMINAL_DEBUG_ENCODINGS,
+                               " output \"%s\" bytes read %u written %u\n",
+                               converted ? converted : "(null)", bytes_read, bytes_written);
+        if (error)
+          _terminal_debug_print (TERMINAL_DEBUG_ENCODINGS,
+                                 " Error: %s\n",
+                                 error->message);
+      }
+    else
+        _terminal_debug_print (TERMINAL_DEBUG_ENCODINGS,
+                               "Encoding %s is valid\n\n",
+                               terminal_encoding_get_charset (encoding));
+  }
+#endif
+
+  g_clear_error (&error);
+  g_free (converted);
+
+  encoding->validity_checked = TRUE;
+  return encoding->valid;
+}
+
+GType
+terminal_encoding_get_type (void)
+{
+  static GType type = 0;
+
+  if (G_UNLIKELY (type == 0)) {
+    type = g_boxed_type_register_static (I_("TerminalEncoding"),
+                                         (GBoxedCopyFunc) terminal_encoding_ref,
+                                         (GBoxedFreeFunc) terminal_encoding_unref);
+  }
+
+  return type;
+}
+
+static void
+update_active_encodings_mateconf (void)
+{
+  GSList *list, *l;
+  GSList *strings = NULL;
+  MateConfClient *conf;
+
+  list = terminal_app_get_active_encodings (terminal_app_get ());
+  for (l = list; l != NULL; l = l->next)
+    {
+      TerminalEncoding *encoding = (TerminalEncoding *) l->data;
+
+      strings = g_slist_prepend (strings, (gpointer) terminal_encoding_get_id (encoding));
+    }
+
+  conf = mateconf_client_get_default ();
+  mateconf_client_set_list (conf,
+                         CONF_GLOBAL_PREFIX"/active_encodings",
+                         MATECONF_VALUE_STRING,
+                         strings,
+                         NULL);
+  g_object_unref (conf);
+
+  g_slist_free (strings);
+  g_slist_foreach (list, (GFunc) terminal_encoding_unref, NULL);
+  g_slist_free (list);
+}
+
+static void
+response_callback (GtkWidget *window,
+                   int        id,
+                   EncodingDialogData *data)
+{
+  if (id == GTK_RESPONSE_HELP)
+    terminal_util_show_help ("mate-terminal-encoding-add", GTK_WINDOW (window));
+  else
+    gtk_widget_destroy (GTK_WIDGET (window));
+}
+
+enum
+{
+  COLUMN_NAME,
+  COLUMN_CHARSET,
+  COLUMN_DATA,
+  N_COLUMNS
+};
+
+static void
+selection_changed_cb (GtkTreeSelection *selection,
+                      EncodingDialogData *data)
+{
+  GtkWidget *button;
+  gboolean have_selection;
+
+  if (selection == data->available_selection)
+    button = data->add_button;
+  else if (selection == data->active_selection)
+    button = data->remove_button;
+  else
+    g_assert_not_reached ();
+
+  have_selection = gtk_tree_selection_get_selected (selection, NULL, NULL);
+  gtk_widget_set_sensitive (button, have_selection);
+}
+
+static void
+button_clicked_cb (GtkWidget *button,
+                   EncodingDialogData *data)
+{
+  GtkTreeSelection *selection;
+  GtkTreeModel *model;
+  GtkTreeIter filter_iter, iter;
+  TerminalEncoding *encoding;
+
+  if (button == data->add_button)
+    selection = data->available_selection;
+  else if (button == data->remove_button)
+    selection = data->active_selection;
+  else
+    g_assert_not_reached ();
+
+  if (!gtk_tree_selection_get_selected (selection, &model, &filter_iter))
+    return;
+
+  gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model),
+                                                    &iter,
+                                                    &filter_iter);
+
+  model = GTK_TREE_MODEL (data->base_store);
+  gtk_tree_model_get (model, &iter, COLUMN_DATA, &encoding, -1);
+  g_assert (encoding != NULL);
+
+  if (button == data->add_button)
+    encoding->is_active = TRUE;
+  else if (button == data->remove_button)
+    encoding->is_active = FALSE;
+  else
+    g_assert_not_reached ();
+
+  terminal_encoding_unref (encoding);
+
+  /* We don't need to emit row-changed here, since updating the mateconf pref
+   * will update the models.
+   */
+  update_active_encodings_mateconf ();
+}
+
+static void
+liststore_insert_encoding (gpointer key,
+                           TerminalEncoding *encoding,
+                           GtkListStore *store)
+{
+  GtkTreeIter iter;
+
+  if (!terminal_encoding_is_valid (encoding))
+    return;
+
+  gtk_list_store_insert_with_values (store, &iter, -1,
+                                     COLUMN_CHARSET, terminal_encoding_get_charset (encoding),
+                                     COLUMN_NAME, encoding->name,
+                                     COLUMN_DATA, encoding,
+                                     -1);
+}
+
+static gboolean
+filter_active_encodings (GtkTreeModel *child_model,
+                         GtkTreeIter *child_iter,
+                         gpointer data)
+{
+  TerminalEncoding *encoding;
+  gboolean active = GPOINTER_TO_UINT (data);
+  gboolean visible;
+
+  gtk_tree_model_get (child_model, child_iter, COLUMN_DATA, &encoding, -1);
+  visible = active ? encoding->is_active : !encoding->is_active;
+  terminal_encoding_unref (encoding);
+
+  return visible;
+}
+
+static GtkTreeModel *
+encodings_create_treemodel (GtkListStore *base_store,
+                            gboolean active)
+{
+  GtkTreeModel *model;
+
+  model = gtk_tree_model_filter_new (GTK_TREE_MODEL (base_store), NULL);
+  gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (model),
+                                          filter_active_encodings,
+                                          GUINT_TO_POINTER (active), NULL);
+
+  return model;
+}
+
+static void
+encodings_list_changed_cb (TerminalApp *app,
+                           EncodingDialogData *data)
+{
+  gtk_list_store_clear (data->base_store);
+
+  g_hash_table_foreach (terminal_app_get_encodings (app), (GHFunc) liststore_insert_encoding, data->base_store);
+}
+
+static void
+encoding_dialog_data_free (EncodingDialogData *data)
+{
+  g_signal_handlers_disconnect_by_func (terminal_app_get (),
+                                        G_CALLBACK (encodings_list_changed_cb),
+                                        data);
+
+  g_free (data);
+}
+
+void
+terminal_encoding_dialog_show (GtkWindow *transient_parent)
+{
+  TerminalApp *app;
+  GtkCellRenderer *cell_renderer;
+  GtkTreeViewColumn *column;
+  GtkTreeModel *model;
+  EncodingDialogData *data;
+
+  if (encoding_dialog)
+    {
+      gtk_window_set_transient_for (GTK_WINDOW (encoding_dialog), transient_parent);
+      gtk_window_present (GTK_WINDOW (encoding_dialog));
+      return;
+    }
+
+  data = g_new (EncodingDialogData, 1);
+
+  if (!terminal_util_load_builder_file ("encodings-dialog.ui",
+                                        "encodings-dialog", &data->dialog,
+                                        "add-button", &data->add_button,
+                                        "remove-button", &data->remove_button,
+                                        "available-treeview", &data->available_tree_view,
+                                        "displayed-treeview", &data->active_tree_view,
+                                        NULL))
+    {
+      g_free (data);
+      return;
+    }
+
+  g_object_set_data_full (G_OBJECT (data->dialog), "GT::Data", data, (GDestroyNotify) encoding_dialog_data_free);
+
+  gtk_window_set_transient_for (GTK_WINDOW (data->dialog), transient_parent);
+  gtk_window_set_role (GTK_WINDOW (data->dialog), "mate-terminal-encodings");
+  g_signal_connect (data->dialog, "response",
+                    G_CALLBACK (response_callback), data);
+
+  /* buttons */
+  g_signal_connect (data->add_button, "clicked",
+                    G_CALLBACK (button_clicked_cb), data);
+
+  g_signal_connect (data->remove_button, "clicked",
+                    G_CALLBACK (button_clicked_cb), data);
+  
+  /* Tree view of available encodings */
+  /* Column 1 */
+  cell_renderer = gtk_cell_renderer_text_new ();
+  column = gtk_tree_view_column_new_with_attributes (_("_Description"),
+						     cell_renderer,
+						     "text", COLUMN_NAME,
+						     NULL);
+  gtk_tree_view_append_column (data->available_tree_view, column);
+  gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME);
+  
+  /* Column 2 */
+  cell_renderer = gtk_cell_renderer_text_new ();
+  column = gtk_tree_view_column_new_with_attributes (_("_Encoding"),
+						     cell_renderer,
+						     "text", COLUMN_CHARSET,
+						     NULL);
+  gtk_tree_view_append_column (data->available_tree_view, column);
+  gtk_tree_view_column_set_sort_column_id (column, COLUMN_CHARSET);  
+
+  data->available_selection = gtk_tree_view_get_selection (data->available_tree_view);
+  gtk_tree_selection_set_mode (data->available_selection, GTK_SELECTION_BROWSE);
+
+  g_signal_connect (data->available_selection, "changed",
+                    G_CALLBACK (selection_changed_cb), data);
+
+  /* Tree view of selected encodings */
+  /* Column 1 */
+  cell_renderer = gtk_cell_renderer_text_new ();
+  column = gtk_tree_view_column_new_with_attributes (_("_Description"),
+						     cell_renderer,
+						     "text", COLUMN_NAME,
+						     NULL);
+  gtk_tree_view_append_column (data->active_tree_view, column);
+  gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME);
+  
+  /* Column 2 */
+  cell_renderer = gtk_cell_renderer_text_new ();
+  column = gtk_tree_view_column_new_with_attributes (_("_Encoding"),
+						     cell_renderer,
+						     "text", COLUMN_CHARSET,
+						     NULL);
+  gtk_tree_view_append_column (data->active_tree_view, column);
+  gtk_tree_view_column_set_sort_column_id (column, COLUMN_CHARSET);  
+
+  /* Add the data */
+
+  data->active_selection = gtk_tree_view_get_selection (data->active_tree_view);
+  gtk_tree_selection_set_mode (data->active_selection, GTK_SELECTION_BROWSE);
+
+  g_signal_connect (data->active_selection, "changed",
+                    G_CALLBACK (selection_changed_cb), data);
+
+  data->base_store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, TERMINAL_TYPE_ENCODING);
+
+  app = terminal_app_get ();
+  encodings_list_changed_cb (app, data);
+  g_signal_connect (app, "encoding-list-changed",
+                    G_CALLBACK (encodings_list_changed_cb), data);
+
+  /* Now turn on sorting */
+  gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->base_store),
+                                        COLUMN_NAME,
+                                        GTK_SORT_ASCENDING);
+  
+  model = encodings_create_treemodel (data->base_store, FALSE);
+  gtk_tree_view_set_model (data->available_tree_view, model);
+  g_object_unref (model);
+
+  model = encodings_create_treemodel (data->base_store, TRUE);
+  gtk_tree_view_set_model (data->active_tree_view, model);
+  g_object_unref (model);
+
+  g_object_unref (data->base_store);
+
+  gtk_window_present (GTK_WINDOW (data->dialog));
+
+  encoding_dialog = data->dialog;
+  g_signal_connect (data->dialog, "destroy",
+                    G_CALLBACK (gtk_widget_destroyed), &encoding_dialog);
+}
+
+GHashTable *
+terminal_encodings_get_builtins (void)
+{
+  GHashTable *encodings_hashtable;
+  guint i;
+  TerminalEncoding *encoding;
+
+  encodings_hashtable = g_hash_table_new_full (g_str_hash, g_str_equal,
+                                               NULL,
+                                               (GDestroyNotify) terminal_encoding_unref);
+
+
+  /* Placeholder entry for the current locale's charset */
+  encoding = terminal_encoding_new ("current",
+                                    _("Current Locale"),
+                                    FALSE,
+                                    TRUE);
+  g_hash_table_insert (encodings_hashtable,
+                       (gpointer) terminal_encoding_get_id (encoding),
+                       encoding);
+
+  for (i = 0; i < G_N_ELEMENTS (encodings); ++i)
+    {
+      encoding = terminal_encoding_new (encodings[i].charset,
+                                        _(encodings[i].name),
+                                        FALSE,
+                                        FALSE);
+      g_hash_table_insert (encodings_hashtable,
+                           (gpointer) terminal_encoding_get_id (encoding),
+                           encoding);
+    }
+
+  return encodings_hashtable;
+}