X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fui%2Fgui%2Fpsppire-window.c;h=4b40f94d1e04e0a055a58703ad21d47b66adfc8a;hb=29917c4f5908454803e663d2ad78bca4bc35e805;hp=3124fb47c7535501497acdcf5c13e28862c65294;hpb=26763488cfe4213eb1dfdc5966a3659a0e89887f;p=pspp diff --git a/src/ui/gui/psppire-window.c b/src/ui/gui/psppire-window.c index 3124fb47c7..4b40f94d1e 100644 --- a/src/ui/gui/psppire-window.c +++ b/src/ui/gui/psppire-window.c @@ -1,5 +1,5 @@ /* PSPPIRE - a graphical user interface for PSPP. - Copyright (C) 2009 Free Software Foundation + Copyright (C) 2009, 2010, 2011, 2013, 2014, 2020 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 @@ -15,14 +15,12 @@ along with this program. If not, see . */ #include +#include +#include "psppire-window.h" +#include "psppire-window-base.h" -#include -#include -#include -#include -#include -#include +#include #include @@ -30,81 +28,125 @@ #define _(msgid) gettext (msgid) #define N_(msgid) msgid -#include "psppire-window.h" +#include "data/any-reader.h" +#include "data/file-handle-def.h" +#include "data/dataset.h" +#include "libpspp/version.h" +#include "output/output-item.h" +#include "output/pivot-table.h" +#include "output/spv/spv.h" +#include "output/spv/spv-output.h" +#include "output/spv/spv-select.h" + +#include "helper.h" +#include "psppire-data-window.h" +#include "psppire-encoding-selector.h" +#include "psppire-syntax-window.h" #include "psppire-window-register.h" -#include "psppire-conf.h" -static void psppire_window_base_finalize (PsppireWindowClass *, gpointer); -static void psppire_window_base_init (PsppireWindowClass *class); static void psppire_window_class_init (PsppireWindowClass *class); static void psppire_window_init (PsppireWindow *window); - static GObjectClass *parent_class; -GType -psppire_window_get_type (void) -{ - static GType psppire_window_type = 0; - - if (!psppire_window_type) - { - static const GTypeInfo psppire_window_info = - { - sizeof (PsppireWindowClass), - (GBaseInitFunc) psppire_window_base_init, - (GBaseFinalizeFunc) psppire_window_base_finalize, - (GClassInitFunc) psppire_window_class_init, - (GClassFinalizeFunc) NULL, - NULL, - sizeof (PsppireWindow), - 0, - (GInstanceInitFunc) psppire_window_init, - }; - - psppire_window_type = - g_type_register_static (GTK_TYPE_WINDOW, "PsppireWindow", - &psppire_window_info, G_TYPE_FLAG_ABSTRACT); - } - - return psppire_window_type; -} - +G_DEFINE_ABSTRACT_TYPE (PsppireWindow, psppire_window, PSPPIRE_TYPE_WINDOW_BASE) /* Properties */ enum { PROP_0, PROP_FILENAME, - PROP_DESCRIPTION + PROP_DESCRIPTION, + PROP_ID }; -gchar * -uniquify (const gchar *str, int *x) -{ - return g_strdup_printf ("%s%d", str, (*x)++); -} - -static gchar mdash[6] = {0,0,0,0,0,0}; - static void psppire_window_set_title (PsppireWindow *window) { GString *title = g_string_sized_new (80); - g_string_printf (title, _("%s %s PSPPIRE %s"), - window->basename ? window->basename : "", - mdash, window->description); + if (window->edited != NULL) + g_string_append_c (title, '*'); - if (window->dirty) - g_string_prepend_c (title, '*'); + if (window->basename || window->id) + { + if (window->basename) + g_string_append_printf (title, "%s ", window->basename); + + if (window->id) + g_string_append_printf (title, "[%s] ", window->id); + + g_string_append_unichar (title, 0x2014); /* em dash */ + g_string_append_c (title, ' '); /* em dash */ + } + + g_string_append_printf (title, "PSPPIRE %s", window->description); + + int minor = 1; + sscanf (bare_version, "%*d.%d.%*d", &minor); + if (minor % 2) + g_string_append_printf (title, " - Test version! Please report bugs to %s", PACKAGE_BUGREPORT); gtk_window_set_title (GTK_WINDOW (window), title->str); g_string_free (title, TRUE); } +static void +psppire_window_update_list_name (PsppireWindow *window) +{ + PsppireWindowRegister *reg = psppire_window_register_new (); + GString *candidate = g_string_sized_new (80); + int n; + + n = 1; + do + { + /* Compose a name. */ + g_string_truncate (candidate, 0); + if (window->filename) + { + gchar *display_filename = g_filename_display_name (window->filename); + g_string_append (candidate, display_filename); + g_free (display_filename); + + if (window->id) + g_string_append_printf (candidate, " [%s]", window->id); + } + else if (window->id) + g_string_append_printf (candidate, "[%s]", window->id); + else + g_string_append (candidate, window->description); + + if (n++ > 1) + g_string_append_printf (candidate, " #%d", n); + + if (window->list_name && !strcmp (candidate->str, window->list_name)) + { + /* Keep the existing name. */ + g_string_free (candidate, TRUE); + return; + } + } + while (psppire_window_register_lookup (reg, candidate->str)); + + if (window->list_name) + psppire_window_register_remove (reg, window->list_name); + + g_free (window->list_name); + window->list_name = g_string_free (candidate, FALSE); + + psppire_window_register_insert (reg, window, window->list_name); +} + +static void +psppire_window_name_changed (PsppireWindow *window) +{ + psppire_window_set_title (window); + psppire_window_update_list_name (window); +} + static void psppire_window_set_property (GObject *object, guint prop_id, @@ -116,50 +158,23 @@ psppire_window_set_property (GObject *object, switch (prop_id) { case PROP_DESCRIPTION: + g_free (window->description); window->description = g_value_dup_string (value); psppire_window_set_title (window); break; case PROP_FILENAME: - { - PsppireWindowRegister *reg = psppire_window_register_new (); - - gchar *candidate_name ; - - { - const gchar *name = g_value_get_string (value); - int x = 0; - GValue def = {0}; - g_value_init (&def, pspec->value_type); - - if ( NULL == name) - { - g_param_value_set_default (pspec, &def); - name = g_value_get_string (&def); - } - - candidate_name = strdup (name); - - while ( psppire_window_register_lookup (reg, candidate_name)) - { - free (candidate_name); - candidate_name = uniquify (name, &x); - } - - window->basename = g_path_get_basename (candidate_name); - - g_value_unset (&def); - } - - psppire_window_set_title (window); - - if ( window->name) - psppire_window_register_remove (reg, window->name); - - free (window->name); - window->name = candidate_name; - - psppire_window_register_insert (reg, window, window->name); - } + g_free (window->filename); + window->filename = g_value_dup_string (value); + g_free (window->basename); + window->basename = (window->filename + ? g_filename_display_basename (window->filename) + : NULL); + psppire_window_name_changed (window); + break; + case PROP_ID: + g_free (window->id); + window->id = g_value_dup_string (value); + psppire_window_name_changed (window); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); @@ -179,11 +194,14 @@ psppire_window_get_property (GObject *object, switch (prop_id) { case PROP_FILENAME: - g_value_set_string (value, window->name); + g_value_set_string (value, window->filename); break; case PROP_DESCRIPTION: g_value_set_string (value, window->description); break; + case PROP_ID: + g_value_set_string (value, window->id); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -191,30 +209,6 @@ psppire_window_get_property (GObject *object, } -static void -on_realize (GtkWindow *window, gpointer data) -{ - PsppireConf *conf = psppire_conf_new (); - - const gchar *base = G_OBJECT_TYPE_NAME (window); - - psppire_conf_set_window_geometry (conf, base, window); -} - - -static gboolean -on_configure (GtkWidget *window, GdkEventConfigure *event, gpointer data) -{ - const gchar *base = G_OBJECT_TYPE_NAME (window); - - PsppireConf *conf = psppire_conf_new (); - - psppire_conf_save_window_geometry (conf, base, event); - - return FALSE; -} - - static void psppire_window_finalize (GObject *object) { @@ -222,15 +216,17 @@ psppire_window_finalize (GObject *object) PsppireWindowRegister *reg = psppire_window_register_new (); - psppire_window_register_remove (reg, window->name); - free (window->name); - free (window->description); - - g_signal_handler_disconnect (psppire_window_register_new (), - window->remove_handler); + if (window->edited) + g_date_time_unref (window->edited); - g_signal_handler_disconnect (psppire_window_register_new (), - window->insert_handler); + g_signal_handler_disconnect (reg, window->remove_handler); + g_signal_handler_disconnect (reg, window->insert_handler); + psppire_window_register_remove (reg, window->list_name); + g_free (window->filename); + g_free (window->basename); + g_free (window->id); + g_free (window->description); + g_free (window->list_name); g_hash_table_destroy (window->menuitem_table); @@ -238,27 +234,34 @@ psppire_window_finalize (GObject *object) G_OBJECT_CLASS (parent_class)->finalize (object); } - static void psppire_window_class_init (PsppireWindowClass *class) { GObjectClass *object_class = G_OBJECT_CLASS (class); + object_class->finalize = psppire_window_finalize; + GParamSpec *description_spec = - g_param_spec_string ("description", + null_if_empty_param ("description", "Description", "A string describing the usage of the window", - "??????", /*Should be overridden by derived classes */ + NULL, /*Should be overridden by derived classes */ G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE); GParamSpec *filename_spec = - g_param_spec_string ("filename", + null_if_empty_param ("filename", "File name", "The name of the file associated with this window, if any", - "Untitled", + NULL, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); - g_unichar_to_utf8 (0x2014, mdash); + GParamSpec *id_spec = + null_if_empty_param ("id", + "Identifier", + "The PSPP language identifier for the data associated " + "with this window (e.g. dataset name)", + NULL, + G_PARAM_CONSTRUCT | G_PARAM_READWRITE); object_class->set_property = psppire_window_set_property; object_class->get_property = psppire_window_get_property; @@ -271,62 +274,23 @@ psppire_window_class_init (PsppireWindowClass *class) PROP_FILENAME, filename_spec); - parent_class = g_type_class_peek_parent (class); -} - - -static void -psppire_window_base_init (PsppireWindowClass *class) -{ - GObjectClass *object_class = G_OBJECT_CLASS (class); - - object_class->finalize = psppire_window_finalize; -} - - - -static void -psppire_window_base_finalize (PsppireWindowClass *class, - gpointer class_data) -{ -} + g_object_class_install_property (object_class, + PROP_ID, + id_spec); -static void -menu_toggled (GtkCheckMenuItem *mi, gpointer data) -{ - /* Prohibit changes to the state */ - mi->active = !mi->active; + parent_class = g_type_class_peek_parent (class); } -/* Look up the window associated with this menuitem and present it to the user */ -static void -menu_activate (GtkMenuItem *mi, gpointer data) -{ - const gchar *key = data; - - PsppireWindowRegister *reg = psppire_window_register_new (); - - PsppireWindow *window = psppire_window_register_lookup (reg, key); - - gtk_window_present (GTK_WINDOW (window)); -} - static void insert_menuitem_into_menu (PsppireWindow *window, gpointer key) { - GtkWidget *item = gtk_check_menu_item_new_with_label (key); - - g_signal_connect (item, "toggled", G_CALLBACK (menu_toggled), NULL); - g_signal_connect (item, "activate", G_CALLBACK (menu_activate), key); - - gtk_widget_show (item); - - gtk_menu_shell_append (window->menu, item); - - /* Set the state without emitting a signal */ - GTK_CHECK_MENU_ITEM (item)->active = - (psppire_window_register_lookup (psppire_window_register_new (), key) == window); + gchar *filename; + GtkWidget *item; + filename = g_filename_display_name (key); + item = gtk_check_menu_item_new_with_label (filename); + g_object_ref_sink (item); + g_free (filename); g_hash_table_insert (window->menuitem_table, key, item); } @@ -336,7 +300,7 @@ insert_item (gpointer key, gpointer value, gpointer data) { PsppireWindow *window = PSPPIRE_WINDOW (data); - if ( NULL != g_hash_table_lookup (window->menuitem_table, key)) + if (NULL != g_hash_table_lookup (window->menuitem_table, key)) return; insert_menuitem_into_menu (window, key); @@ -347,7 +311,7 @@ static void insert_menuitem (GObject *reg, const gchar *key, gpointer data) { PsppireWindow *window = PSPPIRE_WINDOW (data); - + insert_menuitem_into_menu (window, (gpointer) key); } @@ -356,14 +320,7 @@ static void remove_menuitem (PsppireWindowRegister *reg, const gchar *key, gpointer data) { PsppireWindow *window = PSPPIRE_WINDOW (data); - GtkWidget *item ; - - item = g_hash_table_lookup (window->menuitem_table, key); - g_hash_table_remove (window->menuitem_table, key); - - if (GTK_IS_CONTAINER (window->menu)) - gtk_container_remove (GTK_CONTAINER (window->menu), item); } static void @@ -378,25 +335,30 @@ on_delete (PsppireWindow *w, GdkEvent *event, gpointer user_data) { PsppireWindowRegister *reg = psppire_window_register_new (); - if ( w->dirty ) + if (w->edited != NULL) { gint response = psppire_window_query_save (w); switch (response) { + default: case GTK_RESPONSE_CANCEL: return TRUE; break; case GTK_RESPONSE_APPLY: psppire_window_save (w); + if (w->edited != NULL) + { + /* Save failed, or user exited Save As dialog with Cancel. */ + return TRUE; + } break; case GTK_RESPONSE_REJECT: - default: break; } } - if ( 1 == psppire_window_register_n_items (reg)) + if (1 == psppire_window_register_n_items (reg)) gtk_main_quit (); return FALSE; @@ -406,36 +368,35 @@ on_delete (PsppireWindow *w, GdkEvent *event, gpointer user_data) static void psppire_window_init (PsppireWindow *window) { - window->name = NULL; - window->menu = NULL; + window->filename = NULL; + window->basename = NULL; + window->id = NULL; + window->description = NULL; + window->list_name = NULL; + window->edited = NULL; - window->menuitem_table = g_hash_table_new (g_str_hash, g_str_equal); + window->menuitem_table = g_hash_table_new_full (g_str_hash, g_str_equal, + NULL, g_object_unref); g_signal_connect (window, "realize", G_CALLBACK (insert_existing_items), NULL); - window->insert_handler = g_signal_connect (psppire_window_register_new (), + PsppireWindowRegister *reg = psppire_window_register_new (); + window->insert_handler = g_signal_connect (reg, "inserted", G_CALLBACK (insert_menuitem), window); - window->remove_handler = g_signal_connect (psppire_window_register_new (), + window->remove_handler = g_signal_connect (reg, "removed", G_CALLBACK (remove_menuitem), window); - window->dirty = FALSE; + window->added_separator = FALSE; g_signal_connect_swapped (window, "delete-event", G_CALLBACK (on_delete), window); - g_object_set (window, "icon-name", "psppicon", NULL); - - g_signal_connect (window, "configure-event", - G_CALLBACK (on_configure), window); - - g_signal_connect (window, "realize", - G_CALLBACK (on_realize), window); - + g_object_set (window, "icon-name", "pspp", NULL); } /* @@ -449,42 +410,43 @@ psppire_window_query_save (PsppireWindow *se) GtkWidget *dialog; GtkWidget *cancel_button; - const gchar *description; - const gchar *filename = psppire_window_get_filename (se); - - GTimeVal time; - - g_get_current_time (&time); - - g_object_get (se, "description", &description, NULL); - - g_return_val_if_fail (filename != NULL, GTK_RESPONSE_NONE); + gchar *description; + GDateTime *now = g_date_time_new_now_utc (); + GTimeSpan timespan = g_date_time_difference (now, se->edited); + g_date_time_unref (now); + if (se->filename) + description = g_filename_display_basename (se->filename); + else if (se->id) + description = g_strdup (se->id); + else + description = g_strdup (se->description); dialog = gtk_message_dialog_new (GTK_WINDOW (se), GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, - _("Save the changes to \"%s\" before closing?"), - filename); + _("Save the changes to `%s' before closing?"), + description); + g_free (description); - g_object_set (dialog, "icon-name", "psppicon", NULL); + g_object_set (dialog, "icon-name", "pspp", NULL); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), _("If you don't save, changes from the last %ld seconds will be permanently lost."), - time.tv_sec - se->savetime.tv_sec); + (long int) (timespan / G_TIME_SPAN_SECOND)); gtk_dialog_add_button (GTK_DIALOG (dialog), _("Close _without saving"), GTK_RESPONSE_REJECT); cancel_button = gtk_dialog_add_button (GTK_DIALOG (dialog), - GTK_STOCK_CANCEL, + _("Cancel"), GTK_RESPONSE_CANCEL); gtk_dialog_add_button (GTK_DIALOG (dialog), - GTK_STOCK_SAVE, + _("Save"), GTK_RESPONSE_APPLY); gtk_widget_grab_focus (cancel_button); @@ -497,16 +459,15 @@ psppire_window_query_save (PsppireWindow *se) } - +/* The return value is encoded in the glib filename encoding. */ const gchar * psppire_window_get_filename (PsppireWindow *w) { - const gchar *name = NULL; - g_object_get (w, "filename", &name, NULL); - return name; + return w->filename; } +/* FILENAME must be encoded in the glib filename encoding. */ void psppire_window_set_filename (PsppireWindow *w, const gchar *filename) { @@ -516,10 +477,8 @@ psppire_window_set_filename (PsppireWindow *w, const gchar *filename) void psppire_window_set_unsaved (PsppireWindow *w) { - if ( w->dirty == FALSE) - g_get_current_time (&w->savetime); - - w->dirty = TRUE; + if (w->edited == NULL) + w->edited = g_date_time_new_now_utc (); psppire_window_set_title (w); } @@ -527,7 +486,7 @@ psppire_window_set_unsaved (PsppireWindow *w) gboolean psppire_window_get_unsaved (PsppireWindow *w) { - return w->dirty; + return w->edited != NULL; } @@ -569,7 +528,8 @@ psppire_window_model_get_type (void) NULL, /* class_data */ 0, 0, /* n_preallocs */ - NULL + NULL, + NULL /* value_table */ }; window_model_type = @@ -588,25 +548,49 @@ psppire_window_save (PsppireWindow *w) { PsppireWindowIface *i = PSPPIRE_WINDOW_MODEL_GET_IFACE (w); - g_assert (PSPPIRE_IS_WINDOW_MODEL (w)); - g_assert (i); - g_return_if_fail (i->save); - i->save (w); + if (w->filename == NULL) + psppire_window_save_as (w); + else + { + i->save (w); + if (w->edited) + g_date_time_unref (w->edited); + w->edited = NULL; - w->dirty = FALSE; - psppire_window_set_title (w); + psppire_window_set_title (w); + } } -extern GtkRecentManager *the_recent_mgr; +void +psppire_window_save_as (PsppireWindow *w) +{ + PsppireWindowIface *i = PSPPIRE_WINDOW_MODEL_GET_IFACE (w); + gchar *old_filename; + + g_assert (i); + g_return_if_fail (i->pick_filename); + + old_filename = w->filename; + w->filename = NULL; + + i->pick_filename (w); + if (w->filename == NULL) + w->filename = old_filename; + else + { + g_free (old_filename); + psppire_window_save (w); + } +} -static void add_most_recent (const char *file_name, GtkRecentManager *rm); -static void delete_recent (const char *file_name, GtkRecentManager *rm); +static void delete_recent (const char *file_name); gboolean -psppire_window_load (PsppireWindow *w, const gchar *file) +psppire_window_load (PsppireWindow *w, const gchar *file, + const gchar *encoding, gpointer hint) { gboolean ok; PsppireWindowIface *i = PSPPIRE_WINDOW_MODEL_GET_IFACE (w); @@ -617,32 +601,301 @@ psppire_window_load (PsppireWindow *w, const gchar *file) g_return_val_if_fail (i->load, FALSE); - ok = i->load (w, file); + ok = i->load (w, file, encoding, hint); - if ( ok ) + if (ok) { - add_most_recent (file, the_recent_mgr); - w->dirty = FALSE; + psppire_window_set_filename (w, file); + if (w->edited) + g_date_time_unref (w->edited); + w->edited = NULL; } else - delete_recent (file, the_recent_mgr); - - psppire_window_set_title (w); + delete_recent (file); return ok; } -/* Puts FILE_NAME into the recent list. - If it's already in the list, it moves it to the top -*/ +GtkWidget * +psppire_window_file_chooser_dialog (PsppireWindow *toplevel) +{ + GtkFileFilter *filter = gtk_file_filter_new (); + GtkWidget *dialog = + gtk_file_chooser_dialog_new (_("Open"), + GTK_WINDOW (toplevel), + GTK_FILE_CHOOSER_ACTION_OPEN, + _("Cancel"), GTK_RESPONSE_CANCEL, + _("Open"), GTK_RESPONSE_ACCEPT, + NULL); + + g_object_set (dialog, "local-only", FALSE, NULL); + + gtk_file_filter_set_name (filter, _("Data and Syntax Files")); + gtk_file_filter_add_mime_type (filter, "application/x-spss-sav"); + gtk_file_filter_add_mime_type (filter, "application/x-spss-por"); + gtk_file_filter_add_mime_type (filter, "application/x-spss-spv"); + gtk_file_filter_add_pattern (filter, "*.zsav"); + gtk_file_filter_add_pattern (filter, "*.sps"); + gtk_file_filter_add_pattern (filter, "*.SPS"); + gtk_file_filter_add_pattern (filter, "*.spv"); + gtk_file_filter_add_pattern (filter, "*.SPV"); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); + + filter = gtk_file_filter_new (); + gtk_file_filter_set_name (filter, _("System Files (*.sav, *.zsav)")); + gtk_file_filter_add_mime_type (filter, "application/x-spss-sav"); + gtk_file_filter_add_pattern (filter, "*.zsav"); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); + + filter = gtk_file_filter_new (); + gtk_file_filter_set_name (filter, _("Portable Files (*.por) ")); + gtk_file_filter_add_mime_type (filter, "application/x-spss-por"); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); + + filter = gtk_file_filter_new (); + gtk_file_filter_set_name (filter, _("Syntax Files (*.sps) ")); + gtk_file_filter_add_pattern (filter, "*.sps"); + gtk_file_filter_add_pattern (filter, "*.SPS"); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); + + filter = gtk_file_filter_new (); + gtk_file_filter_set_name (filter, _("Output Files (*.spv) ")); + gtk_file_filter_add_pattern (filter, "*.spv"); + gtk_file_filter_add_pattern (filter, "*.SPV"); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); + + filter = gtk_file_filter_new (); + gtk_file_filter_set_name (filter, _("All Files")); + gtk_file_filter_add_pattern (filter, "*"); + gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); + + if (toplevel->filename) + { + const gchar *filename = toplevel->filename; + gchar *dir_name; + + if (! g_path_is_absolute (filename)) + { + gchar *path = + g_build_filename (g_get_current_dir (), filename, NULL); + dir_name = g_path_get_dirname (path); + g_free (path); + } + else + { + dir_name = g_path_get_dirname (filename); + } + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), + dir_name); + free (dir_name); + } + + gtk_file_chooser_set_extra_widget ( + GTK_FILE_CHOOSER (dialog), + psppire_encoding_selector_new ("Auto", true)); + + return dialog; +} + +struct item_path + { + const struct spv_item **nodes; + size_t n; + +#define N_STUB 10 + const struct spv_item *stub[N_STUB]; + }; + static void -add_most_recent (const char *file_name, GtkRecentManager *rm) +swap_nodes (const struct spv_item **a, const struct spv_item **b) { - gchar *uri = g_filename_to_uri (file_name, NULL, NULL); + const struct spv_item *tmp = *a; + *a = *b; + *b = tmp; +} - if ( uri ) - gtk_recent_manager_add_item (rm, uri); +static void +get_path (const struct spv_item *item, struct item_path *path) +{ + size_t allocated = 10; + path->nodes = path->stub; + path->n = 0; + + while (item) + { + if (path->n >= allocated) + { + if (path->nodes == path->stub) + path->nodes = xmemdup (path->stub, sizeof path->stub); + path->nodes = x2nrealloc (path->nodes, &allocated, + sizeof *path->nodes); + } + path->nodes[path->n++] = item; + item = item->parent; + } + + for (size_t i = 0; i < path->n / 2; i++) + swap_nodes (&path->nodes[i], &path->nodes[path->n - i - 1]); +} + +static void +free_path (struct item_path *path) +{ + if (path && path->nodes != path->stub) + free (path->nodes); +} + +static void +dump_heading_transition (const struct spv_item *old, + const struct spv_item *new) +{ + if (old == new) + return; + + struct item_path old_path, new_path; + get_path (old, &old_path); + get_path (new, &new_path); + + size_t common = 0; + for (; common < old_path.n && common < new_path.n; common++) + if (old_path.nodes[common] != new_path.nodes[common]) + break; + + for (size_t i = common; i < old_path.n; i++) + output_item_submit (group_close_item_create ()); + for (size_t i = common; i < new_path.n; i++) + output_item_submit (group_open_item_create ( + new_path.nodes[i]->command_id, + new_path.nodes[i]->label)); + + free_path (&old_path); + free_path (&new_path); +} + +void +read_spv_file (const char *filename) +{ + struct spv_reader *spv; + char *error = spv_open (filename, &spv); + if (error) + { + /* XXX */ + fprintf (stderr, "%s\n", error); + return; + } + + struct spv_item **items; + size_t n_items; + spv_select (spv, NULL, 0, &items, &n_items); + struct spv_item *prev_heading = spv_get_root (spv); + for (size_t i = 0; i < n_items; i++) + { + struct spv_item *heading + = items[i]->type == SPV_ITEM_HEADING ? items[i] : items[i]->parent; + dump_heading_transition (prev_heading, heading); + if (items[i]->type == SPV_ITEM_TEXT) + spv_text_submit (items[i]); + else if (items[i]->type == SPV_ITEM_TABLE) + pivot_table_submit (pivot_table_ref (spv_item_get_table (items[i]))); + else if (items[i]->type == SPV_ITEM_IMAGE) + { + cairo_surface_t *image = spv_item_get_image (items[i]); + output_item_submit (image_item_create (cairo_surface_reference ( + image))); + } + prev_heading = heading; + } + dump_heading_transition (prev_heading, spv_get_root (spv)); + free (items); + spv_close (spv); +} + +/* Callback for the file_open action. + Prompts for a filename and opens it */ +void +psppire_window_open (PsppireWindow *de) +{ + GtkWidget *dialog = psppire_window_file_chooser_dialog (de); + + gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), relocate (examples_dir), NULL); + + switch (gtk_dialog_run (GTK_DIALOG (dialog))) + { + case GTK_RESPONSE_ACCEPT: + { + gchar *name = + gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); + + const gchar **cs = NULL; + g_get_filename_charsets (&cs); + + gchar *encoding = psppire_encoding_selector_get_encoding ( + gtk_file_chooser_get_extra_widget (GTK_FILE_CHOOSER (dialog))); + + struct file_handle *fh = fh_create_file (NULL, name, cs[0], fh_default_properties ()); + + int retval = any_reader_detect (fh, NULL); + if (retval == 1) + open_data_window (de, name, encoding, NULL); + else if (retval == 0) + { + char *error = spv_detect (name); + if (!error) + read_spv_file (name); + else + { + free (error); + open_syntax_window (name, encoding); + } + } + + g_free (encoding); + fh_unref (fh); + g_free (name); + } + break; + default: + break; + } + + gtk_widget_destroy (dialog); +} + + +/* Puts FILE_NAME (encoded in the glib file name encoding) into the recent list + with associated MIME_TYPE. If it's already in the list, it moves it to the + top. */ +void +add_most_recent (const char *file_name, + const char *mime_type, const char *encoding) +{ + gchar *uri = g_filename_to_uri (file_name, NULL, NULL); + if (uri) + { + GtkRecentData recent_data; + gchar *full_mime_type; + + if (encoding && encoding[0]) + full_mime_type = g_strdup_printf ("%s; charset=%s", + mime_type, encoding); + else + full_mime_type = g_strdup (mime_type); + + recent_data.display_name = NULL; + recent_data.description = NULL; + recent_data.mime_type = full_mime_type; + recent_data.app_name = CONST_CAST (gchar *, g_get_application_name ()); + recent_data.app_exec = g_strjoin (" ", g_get_prgname (), "%u", NULL); + recent_data.groups = NULL; + recent_data.is_private = FALSE; + + gtk_recent_manager_add_full (gtk_recent_manager_get_default (), + uri, &recent_data); + + g_free (recent_data.app_exec); + g_free (full_mime_type); + } g_free (uri); } @@ -653,13 +906,12 @@ add_most_recent (const char *file_name, GtkRecentManager *rm) If FILE_NAME exists in the recent list, then delete it. */ static void -delete_recent (const char *file_name, GtkRecentManager *rm) +delete_recent (const char *file_name) { gchar *uri = g_filename_to_uri (file_name, NULL, NULL); - if ( uri ) - gtk_recent_manager_remove_item (rm, uri, NULL); + if (uri) + gtk_recent_manager_remove_item (gtk_recent_manager_get_default (), uri, NULL); g_free (uri); } -