From: Ben Pfaff Date: Fri, 13 May 2011 04:07:12 +0000 (-0700) Subject: gui: Recode syntax files on load and save. X-Git-Tag: v0.7.9~290 X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=380110cc2fc8ee8511c2c4a1b3ee1da8a70cdb18;p=pspp-builds.git gui: Recode syntax files on load and save. This adds a new widget that allows an encoding to be selected to the File|Open dialog box, as well as to the File|Save As... dialog box for syntax files only. Files are recoded to UTF-8 on load and back to the original encoding on save. File|Recent Files doesn't yet properly save the encoding information. That's coming up in the next commit. Bug #33254. Thanks to John Darrington for reporting this problem. --- diff --git a/Smake b/Smake index 83c583a3..4cbe44ec 100644 --- a/Smake +++ b/Smake @@ -8,6 +8,7 @@ GNULIB_MODULES = \ assert \ byteswap \ c-strcase \ + c-strcasestr \ c-ctype \ c-strtod \ clean-temp \ diff --git a/src/ui/gui/automake.mk b/src/ui/gui/automake.mk index f004fa60..30af3923 100644 --- a/src/ui/gui/automake.mk +++ b/src/ui/gui/automake.mk @@ -185,6 +185,8 @@ src_ui_gui_psppire_SOURCES = \ src/ui/gui/psppire-dict.h \ src/ui/gui/psppire-dictview.c \ src/ui/gui/psppire-dictview.h \ + src/ui/gui/psppire-encoding-selector.c \ + src/ui/gui/psppire-encoding-selector.h \ src/ui/gui/psppire-hbuttonbox.h \ src/ui/gui/psppire-keypad.h \ src/ui/gui/psppire-output-window.c \ diff --git a/src/ui/gui/helper.c b/src/ui/gui/helper.c index 75954fbd..3f52a61f 100644 --- a/src/ui/gui/helper.c +++ b/src/ui/gui/helper.c @@ -290,7 +290,7 @@ paste_syntax_to_window (gchar *syntax) if ( NULL == the_syntax_pasteboard) { - the_syntax_pasteboard = psppire_syntax_window_new (); + the_syntax_pasteboard = psppire_syntax_window_new (NULL); g_signal_connect (the_syntax_pasteboard, "delete-event", G_CALLBACK (on_delete), &the_syntax_pasteboard); } diff --git a/src/ui/gui/psppire-data-window.c b/src/ui/gui/psppire-data-window.c index 0f14179a..604bd566 100644 --- a/src/ui/gui/psppire-data-window.c +++ b/src/ui/gui/psppire-data-window.c @@ -770,7 +770,7 @@ on_recent_files_select (GtkMenuShell *menushell, gpointer user_data) g_free (uri); - se = psppire_syntax_window_new (); + se = psppire_syntax_window_new (NULL); if ( psppire_window_load (PSPPIRE_WINDOW (se), file) ) gtk_widget_show (se); diff --git a/src/ui/gui/psppire-encoding-selector.c b/src/ui/gui/psppire-encoding-selector.c new file mode 100644 index 00000000..2e861df2 --- /dev/null +++ b/src/ui/gui/psppire-encoding-selector.c @@ -0,0 +1,255 @@ +/* PSPPIRE - a graphical user interface for PSPP. + Copyright (C) 2011 Free Software Foundation, Inc. + + 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 . */ + +#include + +#include "ui/gui/psppire-encoding-selector.h" + +#include +#include + +#include "libpspp/cast.h" +#include "libpspp/compiler.h" +#include "libpspp/i18n.h" + +#include "gl/c-strcase.h" +#include "gl/localcharset.h" +#include "gl/xalloc.h" +#include "gl/xvasprintf.h" + +#include "gettext.h" +#define _(msgid) gettext (msgid) +#define N_(msgid) msgid + +enum + { + COL_DESCRIPTION, + COL_ENCODING + }; + +static void SENTINEL (0) +add_encodings (GtkTreeStore *store, const char *category, ...) +{ + const char *encodings[16]; + va_list args; + int n; + + /* Count encoding arguments. */ + va_start (args, category); + n = 0; + while ((encodings[n] = va_arg (args, const char *)) != NULL) + { + const char *encoding = encodings[n]; + if (!strcmp (encoding, "Auto") || is_encoding_supported (encoding)) + n++; + } + assert (n < sizeof encodings / sizeof *encodings); + va_end (args); + + if (n == 0) + return; + + va_start (args, category); + if (n == 1) + { + char *description; + + if (strcmp (encodings[0], "Auto")) + description = xasprintf ("%s (%s)", category, encodings[0]); + else + description = xstrdup (category); + + gtk_tree_store_insert_with_values ( + store, NULL, NULL, G_MAXINT, + COL_DESCRIPTION, description, + COL_ENCODING, encodings[0], + -1); + + free (description); + } + else + { + GtkTreeIter head; + int i; + + gtk_tree_store_insert_with_values ( + store, &head, NULL, G_MAXINT, + COL_DESCRIPTION, category, + -1); + + for (i = 0; i < n; i++) + gtk_tree_store_insert_with_values ( + store, NULL, &head, G_MAXINT, + COL_DESCRIPTION, encodings[i], + COL_ENCODING, encodings[i], + -1); + } + va_end (args); +} + +static void +set_sensitive (GtkCellLayout *cell_layout, + GtkCellRenderer *cell, + GtkTreeModel *tree_model, + GtkTreeIter *iter, + gpointer data) +{ + gboolean sensitive; + + sensitive = !gtk_tree_model_iter_has_child (tree_model, iter); + g_object_set (cell, "sensitive", sensitive, NULL); +} + +struct find_default_encoding_aux + { + const char *default_encoding; + GtkTreeIter iter; + }; + +static gboolean +find_default_encoding (GtkTreeModel *model, + GtkTreePath *path, + GtkTreeIter *iter, + gpointer aux_) +{ + struct find_default_encoding_aux *aux = aux_; + gchar *encoding; + gboolean found; + + gtk_tree_model_get (model, iter, COL_ENCODING, &encoding, -1); + found = encoding != NULL && !c_strcasecmp (encoding, aux->default_encoding); + if (found) + aux->iter = *iter; + g_free (encoding); + return found; +} + +GtkWidget * +psppire_encoding_selector_new (const char *default_encoding, + gboolean allow_auto) +{ + struct find_default_encoding_aux aux; + GtkCellRenderer *renderer; + GtkWidget *hbox; + GtkWidget *combo_box; + GtkTreeStore *store; + + store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_STRING); + + if (allow_auto) + add_encodings (store, _("Automatically Detect"), "Auto", NULL_SENTINEL); + add_encodings (store, _("Locale Encoding"), locale_charset (), + NULL_SENTINEL); + add_encodings (store, "Unicode", "UTF-8", "UTF-16", "UTF-16BE", "UTF-16LE", + "UTF-32", "UTF-32BE", "UTF-32LE", NULL_SENTINEL); + add_encodings (store, _("Arabic"), "IBM864", "ISO-8859-6", "Windows-1256", + NULL_SENTINEL); + add_encodings (store, _("Armenian"), "ARMSCII-8", NULL_SENTINEL); + add_encodings (store, _("Baltic"), "ISO-8859-13", "ISO-8859-4", + "Windows-1257", NULL_SENTINEL); + add_encodings (store, _("Celtic"), "ISO-8859-14", NULL_SENTINEL); + add_encodings (store, _("Central European"), "IBM852", "ISO-8859-2", + "Mac-CentralEurope", "Windows-1250", NULL_SENTINEL); + add_encodings (store, _("Chinese Simplified"), "GB18030", "GB2312", "GBK", + "HZ-GB-2312", "ISO-2022-CN", NULL_SENTINEL); + add_encodings (store, _("Chinese Traditional"), "Big5", "Big5-HKSCS", + "EUC-TW", NULL_SENTINEL); + add_encodings (store, _("Croatian"), "MacCroatian", NULL_SENTINEL); + add_encodings (store, _("Cyrillic"), "IBM855", "ISO-8859-5", "ISO-IR-111", + "KOI8-R", "MacCyrillic", NULL_SENTINEL); + add_encodings (store, _("Cyrillic/Russian"), "IBM866", NULL_SENTINEL); + add_encodings (store, _("Cyrillic/Ukrainian"), "KOI8-U", "MacUkrainian", + NULL_SENTINEL); + add_encodings (store, _("Georgian"), "GEOSTD8", NULL_SENTINEL); + add_encodings (store, _("Greek"), "ISO-8859-7", "MacGreek", NULL_SENTINEL); + add_encodings (store, _("Gujarati"), "MacGujarati", NULL_SENTINEL); + add_encodings (store, _("Gurmukhi"), "MacGurmukhi", NULL_SENTINEL); + add_encodings (store, _("Hebrew"), "IBM862", "ISO-8859-8-I", "Windows-1255", + NULL_SENTINEL); + add_encodings (store, _("Hebrew Visual"), "ISO-8859-8", NULL_SENTINEL); + add_encodings (store, _("Hindi"), "MacDevangari", NULL_SENTINEL); + add_encodings (store, _("Icelandic"), "MacIcelandic", NULL_SENTINEL); + add_encodings (store, _("Japanese"), "EUC-JP", "ISO-2022-JP", "Shift_JIS", + NULL_SENTINEL); + add_encodings (store, _("Korean"), "EUC-KR", "ISO-2022-KR", "JOHAB", "UHC", + NULL_SENTINEL); + add_encodings (store, _("Nordic"), "ISO-8859-10", NULL_SENTINEL); + add_encodings (store, _("Romanian"), "ISO-8859-16", "MacRomanian", + NULL_SENTINEL); + add_encodings (store, _("South European"), "ISO-8859-3", NULL_SENTINEL); + add_encodings (store, _("Thai"), "ISO-8859-11", "TIS-620", "Windows-874", + NULL_SENTINEL); + add_encodings (store, _("Turkish"), "IBM857", "ISO-8859-9", "Windows-1254", + NULL_SENTINEL); + add_encodings (store, _("Vietnamese"), "TVCN", "VISCII", "VPS", + "Windows-1258", NULL_SENTINEL); + add_encodings (store, _("Western European"), "ISO-8859-1", "ISO-8859-15", + "Windows-1252", "IBM850", "MacRoman", NULL_SENTINEL); + + combo_box = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store)); + + aux.default_encoding = default_encoding ? default_encoding : "Auto"; + gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &aux.iter); + gtk_tree_model_foreach (GTK_TREE_MODEL (store), find_default_encoding, &aux); + gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo_box), &aux.iter); + + g_object_unref (store); + + renderer = gtk_cell_renderer_text_new (); + gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, TRUE); + gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer, + "text", COL_DESCRIPTION, + NULL); + gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo_box), + renderer, set_sensitive, + NULL, NULL); + + hbox = gtk_hbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox), + gtk_label_new (_("Character Encoding: ")), + FALSE, FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox), combo_box, FALSE, TRUE, 0); + gtk_widget_show_all (hbox); + + return hbox; +} + +gchar * +psppire_encoding_selector_get_encoding (GtkWidget *selector) +{ + gchar *encoding = NULL; + GList *list, *pos; + + list = gtk_container_get_children (GTK_CONTAINER (selector)); + for (pos = list; pos; pos = pos->next) + { + GtkWidget *widget = pos->data; + if (GTK_IS_COMBO_BOX (widget)) + { + GtkTreeModel *model; + GtkTreeIter iter; + + if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter)) + break; + + model = gtk_combo_box_get_model (GTK_COMBO_BOX (widget)); + gtk_tree_model_get (model, &iter, COL_ENCODING, &encoding, -1); + break; + } + } + g_list_free (list); + return encoding; +} diff --git a/src/ui/gui/psppire-encoding-selector.h b/src/ui/gui/psppire-encoding-selector.h new file mode 100644 index 00000000..107f8713 --- /dev/null +++ b/src/ui/gui/psppire-encoding-selector.h @@ -0,0 +1,26 @@ +/* PSPPIRE - a graphical user interface for PSPP. + Copyright (C) 2011 Free Software Foundation, Inc. + + 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 . */ + +#ifndef PSPPIRE_ENCODING_SELECTOR_H +#define PSPPIRE_ENCODING_SELECTOR_H 1 + +#include + +GtkWidget *psppire_encoding_selector_new (const char *default_encoding, + gboolean allow_auto); +gchar *psppire_encoding_selector_get_encoding (GtkWidget *selector); + +#endif /* PSPPIRE_ENCODING_SELECTOR_H */ diff --git a/src/ui/gui/psppire-syntax-window.c b/src/ui/gui/psppire-syntax-window.c index 3fa3a0b1..7459a41d 100644 --- a/src/ui/gui/psppire-syntax-window.c +++ b/src/ui/gui/psppire-syntax-window.c @@ -20,18 +20,23 @@ #include #include "language/lexer/lexer.h" +#include "libpspp/encoding-guesser.h" +#include "libpspp/i18n.h" #include "libpspp/message.h" #include "ui/gui/executor.h" #include "ui/gui/help-menu.h" #include "ui/gui/helper.h" #include "ui/gui/psppire-data-window.h" +#include "ui/gui/psppire-encoding-selector.h" #include "ui/gui/psppire-syntax-window.h" #include "ui/gui/psppire-syntax-window.h" #include "ui/gui/psppire-window-register.h" #include "ui/gui/psppire.h" #include "ui/gui/psppire.h" +#include "gl/localcharset.h" #include "gl/xalloc.h" +#include "gl/xvasprintf.h" #include #define _(msgid) gettext (msgid) @@ -46,6 +51,53 @@ static void psppire_syntax_window_init (PsppireSyntaxWindow *synta static void psppire_syntax_window_iface_init (PsppireWindowIface *iface); +/* Properties */ +enum +{ + PROP_0, + PROP_ENCODING +}; + +static void +psppire_syntax_window_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + PsppireSyntaxWindow *window = PSPPIRE_SYNTAX_WINDOW (object); + + switch (prop_id) + { + case PROP_ENCODING: + g_free (window->encoding); + window->encoding = g_value_dup_string (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + }; +} + + +static void +psppire_syntax_window_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + PsppireSyntaxWindow *window = PSPPIRE_SYNTAX_WINDOW (object); + + switch (prop_id) + { + case PROP_ENCODING: + g_value_set_string (value, window->encoding); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + }; +} + GType psppire_syntax_window_get_type (void) { @@ -106,6 +158,9 @@ psppire_syntax_window_dispose (GObject *obj) if (sw->dispose_has_run) return; + g_free (sw->encoding); + sw->encoding = NULL; + clip_selection = gtk_widget_get_clipboard (GTK_WIDGET (sw), GDK_SELECTION_CLIPBOARD); clip_primary = gtk_widget_get_clipboard (GTK_WIDGET (sw), GDK_SELECTION_PRIMARY); @@ -127,9 +182,22 @@ psppire_syntax_window_class_init (PsppireSyntaxWindowClass *class) { GObjectClass *gobject_class = G_OBJECT_CLASS (class); + GParamSpec *encoding_spec = + null_if_empty_param ("encoding", + "Character encoding", + "IANA character encoding in this syntax file", + NULL, + G_PARAM_CONSTRUCT | G_PARAM_READWRITE); + parent_class = g_type_class_peek_parent (class); + gobject_class->set_property = psppire_syntax_window_set_property; + gobject_class->get_property = psppire_syntax_window_get_property; gobject_class->dispose = psppire_syntax_window_dispose; + + g_object_class_install_property (gobject_class, + PROP_ENCODING, + encoding_spec); } @@ -451,6 +519,7 @@ save_editor_to_file (PsppireSyntaxWindow *se, GError **err) { GtkTextBuffer *buffer = se->buffer; + struct substring text_locale; gboolean result ; GtkTextIter start, stop; gchar *text; @@ -465,8 +534,13 @@ save_editor_to_file (PsppireSyntaxWindow *se, text = gtk_text_buffer_get_text (buffer, &start, &stop, FALSE); - result = g_file_set_contents (suffixedname, text, -1, err); + text_locale = recode_substring_pool (se->encoding, "UTF-8", ss_cstr (text), + NULL); + + result = g_file_set_contents (suffixedname, ss_data (text_locale), + ss_length (text_locale), err); + ss_dealloc (&text_locale); g_free (suffixedname); if ( result ) @@ -485,8 +559,10 @@ save_editor_to_file (PsppireSyntaxWindow *se, /* PsppireWindow 'pick_Filename' callback. */ static void -syntax_pick_filename (PsppireWindow *se) +syntax_pick_filename (PsppireWindow *window) { + PsppireSyntaxWindow *se = PSPPIRE_SYNTAX_WINDOW (window); + const char *default_encoding; GtkFileFilter *filter; gint response; @@ -511,14 +587,30 @@ syntax_pick_filename (PsppireWindow *se) gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); + + default_encoding = se->encoding != NULL ? se->encoding : locale_charset (); + gtk_file_chooser_set_extra_widget ( + GTK_FILE_CHOOSER (dialog), + psppire_encoding_selector_new (default_encoding, false)); + response = gtk_dialog_run (GTK_DIALOG (dialog)); if ( response == GTK_RESPONSE_ACCEPT ) { - char *filename = - gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog) ); - psppire_window_set_filename (se, filename); + gchar *encoding; + char *filename; + + filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog) ); + psppire_window_set_filename (window, filename); free (filename); + + encoding = psppire_encoding_selector_get_encoding ( + gtk_file_chooser_get_extra_widget (GTK_FILE_CHOOSER (dialog))); + if (encoding != NULL) + { + g_free (se->encoding); + se->encoding = encoding; + } } gtk_widget_destroy (dialog); @@ -553,14 +645,14 @@ on_quit (GtkMenuItem *menuitem, gpointer user_data) void create_syntax_window (void) { - GtkWidget *w = psppire_syntax_window_new (); + GtkWidget *w = psppire_syntax_window_new (NULL); gtk_widget_show (w); } void -open_syntax_window (const char *file_name) +open_syntax_window (const char *file_name, const gchar *encoding) { - GtkWidget *se = psppire_syntax_window_new (); + GtkWidget *se = psppire_syntax_window_new (encoding); if ( psppire_window_load (PSPPIRE_WINDOW (se), file_name) ) gtk_widget_show (se); @@ -596,6 +688,8 @@ psppire_syntax_window_init (PsppireSyntaxWindow *window) GtkClipboard *clip_selection = gtk_widget_get_clipboard (GTK_WIDGET (window), GDK_SELECTION_CLIPBOARD); GtkClipboard *clip_primary = gtk_widget_get_clipboard (GTK_WIDGET (window), GDK_SELECTION_PRIMARY); + window->encoding = NULL; + window->cliptext = NULL; window->dispose_has_run = FALSE; @@ -726,10 +820,11 @@ psppire_syntax_window_init (PsppireSyntaxWindow *window) GtkWidget* -psppire_syntax_window_new (void) +psppire_syntax_window_new (const char *encoding) { return GTK_WIDGET (g_object_new (psppire_syntax_window_get_type (), "description", _("Syntax Editor"), + "encoding", encoding, NULL)); } @@ -771,6 +866,7 @@ syntax_load (PsppireWindow *window, const gchar *filename) gsize len_utf8 = -1; GtkTextIter iter; PsppireSyntaxWindow *sw = PSPPIRE_SYNTAX_WINDOW (window); + gchar *encoding; /* FIXME: What if it's a very big file ? */ if ( ! g_file_get_contents (filename, &text_locale, &len_locale, &err) ) @@ -780,17 +876,19 @@ syntax_load (PsppireWindow *window, const gchar *filename) return FALSE; } - text_utf8 = g_locale_to_utf8 (text_locale, len_locale, NULL, &len_utf8, &err); - + /* Determine the file's encoding and update sw->encoding. (The ordering is + important here because encoding_guess_whole_file() often returns its + argument instead of a copy of it.) */ + encoding = g_strdup (encoding_guess_whole_file (sw->encoding, text_locale, + len_locale)); + g_free (sw->encoding); + sw->encoding = encoding; + + text_utf8 = recode_substring_pool ("UTF-8", encoding, + ss_buffer (text_locale, len_locale), + NULL).string; free (text_locale); - if ( text_utf8 == NULL ) - { - error_dialog (GTK_WINDOW (window), filename, err); - g_clear_error (&err); - return FALSE; - } - gtk_text_buffer_get_iter_at_line (sw->buffer, &iter, 0); gtk_text_buffer_insert (sw->buffer, &iter, text_utf8, len_utf8); diff --git a/src/ui/gui/psppire-syntax-window.h b/src/ui/gui/psppire-syntax-window.h index 661aaa76..31ceebb2 100644 --- a/src/ui/gui/psppire-syntax-window.h +++ b/src/ui/gui/psppire-syntax-window.h @@ -1,5 +1,5 @@ /* PSPPIRE - a graphical user interface for PSPP. - Copyright (C) 2008, 2010 Free Software Foundation + Copyright (C) 2008, 2010, 2011 Free Software Foundation 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 @@ -45,6 +45,8 @@ struct _PsppireSyntaxWindow /* */ + gchar *encoding; /* File's encoding. */ + GtkTextBuffer *buffer; /* The buffer which contains the text */ GtkWidget *sb; guint text_context; @@ -69,10 +71,10 @@ struct _PsppireSyntaxWindowClass }; GType psppire_syntax_window_get_type (void); -GtkWidget* psppire_syntax_window_new (void); +GtkWidget* psppire_syntax_window_new (const char *encoding); void create_syntax_window (void); -void open_syntax_window (const char *file_name); +void open_syntax_window (const char *file_name, const char *encoding); G_END_DECLS diff --git a/src/ui/gui/psppire-window.c b/src/ui/gui/psppire-window.c index fbb91a78..81fcb8c0 100644 --- a/src/ui/gui/psppire-window.c +++ b/src/ui/gui/psppire-window.c @@ -33,6 +33,7 @@ #include "helper.h" #include "psppire-conf.h" #include "psppire-data-window.h" +#include "psppire-encoding-selector.h" #include "psppire-syntax-window.h" #include "psppire-window-register.h" #include "psppire.h" @@ -788,6 +789,9 @@ psppire_window_file_chooser_dialog (PsppireWindow *toplevel) free (dir_name); } + gtk_file_chooser_set_extra_widget ( + GTK_FILE_CHOOSER (dialog), psppire_encoding_selector_new ("Auto", true)); + return dialog; } @@ -807,11 +811,15 @@ psppire_window_open (PsppireWindow *de) gchar *sysname = convert_glib_filename_to_system_filename (name, NULL); + gchar *encoding = psppire_encoding_selector_get_encoding ( + gtk_file_chooser_get_extra_widget (GTK_FILE_CHOOSER (dialog))); + if (any_reader_may_open (sysname)) open_data_window (de, name); else - open_syntax_window (name); + open_syntax_window (name, encoding); + g_free (encoding); g_free (sysname); g_free (name); }