src/ui/gui/psppire-window.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2009, 2010, 2011  Free Software Foundation
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 #include <config.h>
  18
  19 #include "psppire-window.h"
  20
  21 #include <gtk/gtk.h>
  22
  23 #include <stdlib.h>
  24 #include <xalloc.h>
  25
  26 #include <gettext.h>
  27 #define _(msgid) gettext (msgid)
  28 #define N_(msgid) msgid
  29
  30 #include "data/any-reader.h"
  31 #include "data/file-name.h"
  32 #include "data/dataset.h"
  33
  34 #include "helper.h"
  35 #include "psppire-conf.h"
  36 #include "psppire-data-window.h"
  37 #include "psppire-encoding-selector.h"
  38 #include "psppire-syntax-window.h"
  39 #include "psppire-window-register.h"
  40 #include "psppire.h"
  41
  42 static void psppire_window_base_init     (PsppireWindowClass *class);
  43 static void psppire_window_class_init    (PsppireWindowClass *class);
  44 static void psppire_window_init          (PsppireWindow      *window);
  45
  46
  47 static GObjectClass *parent_class;
  48
  49 GType
  50 psppire_window_get_type (void)
  51 {
  52   static GType psppire_window_type = 0;
  53
  54   if (!psppire_window_type)
  55     {
  56       static const GTypeInfo psppire_window_info =
  57       {
  58         sizeof (PsppireWindowClass),
  59         (GBaseInitFunc) psppire_window_base_init,
  60         (GBaseFinalizeFunc) NULL,
  61         (GClassInitFunc) psppire_window_class_init,
  62         (GClassFinalizeFunc) NULL,
  63         NULL,
  64         sizeof (PsppireWindow),
  65         0,
  66         (GInstanceInitFunc) psppire_window_init,
  67       };
  68
  69       psppire_window_type =
  70         g_type_register_static (GTK_TYPE_WINDOW, "PsppireWindow",
  71                                 &psppire_window_info, G_TYPE_FLAG_ABSTRACT);
  72     }
  73
  74   return psppire_window_type;
  75 }
  76
  77
  78 /* Properties */
  79 enum
  80 {
  81   PROP_0,
  82   PROP_FILENAME,
  83   PROP_DESCRIPTION,
  84   PROP_ID
  85 };
  86
  87
  88 static void
  89 psppire_window_set_title (PsppireWindow *window)
  90 {
  91   GString *title = g_string_sized_new (80);
  92
  93   if (window->dirty)
  94     g_string_append_c (title, '*');
  95
  96   if (window->basename || window->id)
  97     {
  98       if (window->basename)
  99         g_string_append_printf (title, "%s ", window->basename);
 100
 101       if (window->id != '\0')
 102         g_string_append_printf (title, "[%s] ", window->id);
 103
 104       g_string_append_unichar (title, 0x2014); /* em dash */
 105       g_string_append_c (title, ' '); /* em dash */
 106     }
 107
 108   g_string_append_printf (title, "PSPPIRE %s", window->description);
 109
 110   gtk_window_set_title (GTK_WINDOW (window), title->str);
 111
 112   g_string_free (title, TRUE);
 113 }
 114
 115 static void
 116 psppire_window_update_list_name (PsppireWindow *window)
 117 {
 118   PsppireWindowRegister *reg = psppire_window_register_new ();
 119   GString *candidate = g_string_sized_new (80);
 120   int n;
 121
 122   n = 1;
 123   do
 124     {
 125       /* Compose a name. */
 126       g_string_truncate (candidate, 0);
 127       if (window->filename)
 128         {
 129           gchar *display_filename = g_filename_display_name (window->filename);
 130           g_string_append (candidate, display_filename);
 131           g_free (display_filename);
 132
 133           if (window->id)
 134             g_string_append_printf (candidate, " [%s]", window->id);
 135         }
 136       else if (window->id)
 137         g_string_append_printf (candidate, "[%s]", window->id);
 138       else
 139         g_string_append (candidate, window->description);
 140
 141       if (n++ > 1)
 142         g_string_append_printf (candidate, " #%d", n);
 143
 144       if (window->list_name && !strcmp (candidate->str, window->list_name))
 145         {
 146           /* Keep the existing name. */
 147           g_string_free (candidate, TRUE);
 148           return;
 149         }
 150     }
 151   while (psppire_window_register_lookup (reg, candidate->str));
 152
 153   if (window->list_name)
 154     psppire_window_register_remove (reg, window->list_name);
 155
 156   g_free (window->list_name);
 157   window->list_name = g_string_free (candidate, FALSE);
 158
 159   psppire_window_register_insert (reg, window, window->list_name);
 160 }
 161
 162 static void
 163 psppire_window_name_changed (PsppireWindow *window)
 164 {
 165   psppire_window_set_title (window);
 166   psppire_window_update_list_name (window);
 167 }
 168
 169 static void
 170 psppire_window_set_property (GObject         *object,
 171                              guint            prop_id,
 172                              const GValue    *value,
 173                              GParamSpec      *pspec)
 174 {
 175   PsppireWindow *window = PSPPIRE_WINDOW (object);
 176
 177   switch (prop_id)
 178     {
 179     case PROP_DESCRIPTION:
 180       g_free (window->description);
 181       window->description = g_value_dup_string (value);
 182       psppire_window_set_title (window);
 183       break;
 184     case PROP_FILENAME:
 185       g_free (window->filename);
 186       window->filename = g_value_dup_string (value);
 187       g_free (window->basename);
 188       window->basename = (window->filename
 189                           ? g_filename_display_basename (window->filename)
 190                           : NULL);
 191       psppire_window_name_changed (window);
 192       break;
 193       break;
 194     case PROP_ID:
 195       g_free (window->id);
 196       window->id = g_value_dup_string (value);
 197       psppire_window_name_changed (window);
 198       break;
 199     default:
 200       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 201       break;
 202     };
 203 }
 204
 205
 206 static void
 207 psppire_window_get_property (GObject         *object,
 208                              guint            prop_id,
 209                              GValue          *value,
 210                              GParamSpec      *pspec)
 211 {
 212   PsppireWindow *window = PSPPIRE_WINDOW (object);
 213
 214   switch (prop_id)
 215     {
 216     case PROP_FILENAME:
 217       g_value_set_string (value, window->filename);
 218       break;
 219     case PROP_DESCRIPTION:
 220       g_value_set_string (value, window->description);
 221       break;
 222     case PROP_ID:
 223       g_value_set_string (value, window->id);
 224       break;
 225     default:
 226       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 227       break;
 228     };
 229 }
 230
 231
 232 static void
 233 on_realize (GtkWindow *window, gpointer data)
 234 {
 235   PsppireConf *conf = psppire_conf_new ();
 236
 237   const gchar *base = G_OBJECT_TYPE_NAME (window);
 238
 239   psppire_conf_set_window_geometry (conf, base, window);
 240 }
 241
 242
 243 static void
 244 psppire_window_finalize (GObject *object)
 245 {
 246   PsppireWindow *window = PSPPIRE_WINDOW (object);
 247
 248   PsppireWindowRegister *reg = psppire_window_register_new ();
 249
 250   psppire_window_register_remove (reg, window->list_name);
 251   g_free (window->filename);
 252   g_free (window->basename);
 253   g_free (window->id);
 254   g_free (window->description);
 255   g_free (window->list_name);
 256
 257   g_signal_handler_disconnect (psppire_window_register_new (),
 258                                window->remove_handler);
 259
 260   g_signal_handler_disconnect (psppire_window_register_new (),
 261                                window->insert_handler);
 262
 263   g_hash_table_destroy (window->menuitem_table);
 264
 265   if (G_OBJECT_CLASS (parent_class)->finalize)
 266     G_OBJECT_CLASS (parent_class)->finalize (object);
 267 }
 268
 269 static void
 270 psppire_window_class_init (PsppireWindowClass *class)
 271 {
 272   GObjectClass *object_class = G_OBJECT_CLASS (class);
 273
 274   GParamSpec *description_spec =
 275     null_if_empty_param ("description",
 276                        "Description",
 277                        "A string describing the usage of the window",
 278                          NULL, /*Should be overridden by derived classes */
 279                        G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 280
 281   GParamSpec *filename_spec =
 282     null_if_empty_param ("filename",
 283                        "File name",
 284                        "The name of the file associated with this window, if any",
 285                          NULL,
 286                          G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
 287
 288   GParamSpec *id_spec =
 289     null_if_empty_param ("id",
 290                          "Identifier",
 291                          "The PSPP language identifier for the data associated "
 292                          "with this window (e.g. dataset name)",
 293                          NULL,
 294                          G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
 295
 296   object_class->set_property = psppire_window_set_property;
 297   object_class->get_property = psppire_window_get_property;
 298
 299   g_object_class_install_property (object_class,
 300                                    PROP_DESCRIPTION,
 301                                    description_spec);
 302
 303   g_object_class_install_property (object_class,
 304                                    PROP_FILENAME,
 305                                    filename_spec);
 306
 307   g_object_class_install_property (object_class,
 308                                    PROP_ID,
 309                                    id_spec);
 310
 311   parent_class = g_type_class_peek_parent (class);
 312 }
 313
 314
 315 static void
 316 psppire_window_base_init (PsppireWindowClass *class)
 317 {
 318   GObjectClass *object_class = G_OBJECT_CLASS (class);
 319
 320   object_class->finalize = psppire_window_finalize;
 321 }
 322
 323
 324
 325 static void
 326 menu_toggled (GtkCheckMenuItem *mi, gpointer data)
 327 {
 328   /* Prohibit changes to the state */
 329   mi->active = !mi->active;
 330 }
 331
 332
 333 /* Look up the window associated with this menuitem and present it to the user */
 334 static void
 335 menu_activate (GtkMenuItem *mi, gpointer data)
 336 {
 337   const gchar *key = data;
 338
 339   PsppireWindowRegister *reg = psppire_window_register_new ();
 340
 341   PsppireWindow *window = psppire_window_register_lookup (reg, key);
 342
 343   gtk_window_present (GTK_WINDOW (window));
 344 }
 345
 346 static void
 347 insert_menuitem_into_menu (PsppireWindow *window, gpointer key)
 348 {
 349   gchar *filename;
 350   GtkWidget *item;
 351
 352   /* Add a separator before adding the first real item.  If we add a separator
 353      at any other time, sometimes GtkUIManager removes it. */
 354   if (g_hash_table_size (window->menuitem_table) == 0)
 355     {
 356       GtkWidget *separator = gtk_separator_menu_item_new ();
 357       gtk_widget_show (separator);
 358       gtk_menu_shell_append (window->menu, separator);
 359     }
 360
 361   filename = g_filename_display_name (key);
 362   item = gtk_check_menu_item_new_with_label (filename);
 363   g_free (filename);
 364
 365   g_signal_connect (item, "toggled", G_CALLBACK (menu_toggled), NULL);
 366   g_signal_connect (item, "activate", G_CALLBACK (menu_activate), key);
 367
 368   gtk_widget_show (item);
 369
 370   gtk_menu_shell_append (window->menu, item);
 371
 372   /* Set the state without emitting a signal */
 373   GTK_CHECK_MENU_ITEM (item)->active =
 374    (psppire_window_register_lookup (psppire_window_register_new (), key) == window);
 375
 376   g_hash_table_insert (window->menuitem_table, key, item);
 377 }
 378
 379 static void
 380 insert_item (gpointer key, gpointer value, gpointer data)
 381 {
 382   PsppireWindow *window = PSPPIRE_WINDOW (data);
 383
 384   if ( NULL != g_hash_table_lookup (window->menuitem_table, key))
 385     return;
 386
 387   insert_menuitem_into_menu (window, key);
 388 }
 389
 390 /* Insert a new item into the window menu */
 391 static void
 392 insert_menuitem (GObject *reg, const gchar *key, gpointer data)
 393 {
 394   PsppireWindow *window = PSPPIRE_WINDOW (data);
 395
 396   insert_menuitem_into_menu (window, (gpointer) key);
 397 }
 398
 399
 400 static void
 401 remove_menuitem (PsppireWindowRegister *reg, const gchar *key, gpointer data)
 402 {
 403   PsppireWindow *window = PSPPIRE_WINDOW (data);
 404   GtkWidget *item ;
 405
 406   item = g_hash_table_lookup (window->menuitem_table, key);
 407
 408   g_hash_table_remove (window->menuitem_table, key);
 409
 410   if (GTK_IS_CONTAINER (window->menu))
 411     gtk_container_remove (GTK_CONTAINER (window->menu), item);
 412 }
 413
 414 static void
 415 insert_existing_items (PsppireWindow *window)
 416 {
 417   psppire_window_register_foreach (psppire_window_register_new (), insert_item, window);
 418 }
 419
 420
 421 static gboolean
 422 on_delete (PsppireWindow *w, GdkEvent *event, gpointer user_data)
 423 {
 424   PsppireWindowRegister *reg = psppire_window_register_new ();
 425
 426   const gchar *base = G_OBJECT_TYPE_NAME (w);
 427
 428   PsppireConf *conf = psppire_conf_new ();
 429
 430   psppire_conf_save_window_geometry (conf, base, GTK_WINDOW (w));
 431
 432
 433   if ( w->dirty )
 434     {
 435       gint response = psppire_window_query_save (w);
 436
 437       switch (response)
 438         {
 439         default:
 440         case GTK_RESPONSE_CANCEL:
 441           return TRUE;
 442           break;
 443         case GTK_RESPONSE_APPLY:
 444           psppire_window_save (w);
 445           if (w->dirty)
 446             {
 447               /* Save failed, or user exited Save As dialog with Cancel. */
 448               return TRUE;
 449             }
 450           break;
 451         case GTK_RESPONSE_REJECT:
 452           break;
 453         }
 454     }
 455
 456   if ( 1 == psppire_window_register_n_items (reg))
 457     gtk_main_quit ();
 458
 459   return FALSE;
 460 }
 461
 462
 463 static void
 464 psppire_window_init (PsppireWindow *window)
 465 {
 466   window->menu = NULL;
 467   window->filename = NULL;
 468   window->basename = NULL;
 469   window->id = NULL;
 470   window->description = NULL;
 471   window->list_name = NULL;
 472
 473   window->menuitem_table  = g_hash_table_new (g_str_hash, g_str_equal);
 474
 475
 476   g_signal_connect (window,  "realize", G_CALLBACK (insert_existing_items), NULL);
 477
 478   window->insert_handler = g_signal_connect (psppire_window_register_new (),
 479                                              "inserted",
 480                                              G_CALLBACK (insert_menuitem),
 481                                              window);
 482
 483   window->remove_handler = g_signal_connect (psppire_window_register_new (),
 484                                              "removed",
 485                                              G_CALLBACK (remove_menuitem),
 486                                              window);
 487
 488   window->dirty = FALSE;
 489
 490   g_signal_connect_swapped (window, "delete-event", G_CALLBACK (on_delete), window);
 491
 492   g_object_set (window, "icon-name", "pspp", NULL);
 493
 494   g_signal_connect (window, "realize",
 495                     G_CALLBACK (on_realize), window);
 496 }
 497
 498 /*
 499    Ask the user if the buffer should be saved.
 500    Return the response.
 501 */
 502 gint
 503 psppire_window_query_save (PsppireWindow *se)
 504 {
 505   gint response;
 506   GtkWidget *dialog;
 507   GtkWidget *cancel_button;
 508
 509   gchar *description;
 510
 511   GTimeVal time;
 512
 513   g_get_current_time (&time);
 514
 515   if (se->filename)
 516     description = g_filename_display_basename (se->filename);
 517   else if (se->id)
 518     description = g_strdup (se->id);
 519   else
 520     description = g_strdup (se->description);
 521   dialog =
 522     gtk_message_dialog_new (GTK_WINDOW (se),
 523                             GTK_DIALOG_MODAL,
 524                             GTK_MESSAGE_WARNING,
 525                             GTK_BUTTONS_NONE,
 526                             _("Save the changes to `%s' before closing?"),
 527                             description);
 528   g_free (description);
 529
 530   g_object_set (dialog, "icon-name", "pspp", NULL);
 531
 532   gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
 533                                             _("If you don't save, changes from the last %ld seconds will be permanently lost."),
 534                                             time.tv_sec - se->savetime.tv_sec);
 535
 536   gtk_dialog_add_button  (GTK_DIALOG (dialog),
 537                           _("Close _without saving"),
 538                           GTK_RESPONSE_REJECT);
 539
 540   cancel_button = gtk_dialog_add_button  (GTK_DIALOG (dialog),
 541                                           GTK_STOCK_CANCEL,
 542                                           GTK_RESPONSE_CANCEL);
 543
 544   gtk_dialog_add_button  (GTK_DIALOG (dialog),
 545                           GTK_STOCK_SAVE,
 546                           GTK_RESPONSE_APPLY);
 547
 548   gtk_widget_grab_focus (cancel_button);
 549
 550   response = gtk_dialog_run (GTK_DIALOG (dialog));
 551
 552   gtk_widget_destroy (dialog);
 553
 554   return response;
 555 }
 556
 557
 558 /* The return value is encoded in the glib filename encoding. */
 559 const gchar *
 560 psppire_window_get_filename (PsppireWindow *w)
 561 {
 562   return w->filename;
 563 }
 564
 565
 566 /* FILENAME must be encoded in the glib filename encoding. */
 567 void
 568 psppire_window_set_filename (PsppireWindow *w, const gchar *filename)
 569 {
 570   g_object_set (w, "filename", filename, NULL);
 571 }
 572
 573 void
 574 psppire_window_set_unsaved (PsppireWindow *w)
 575 {
 576   if ( w->dirty == FALSE)
 577     g_get_current_time (&w->savetime);
 578
 579   w->dirty = TRUE;
 580
 581   psppire_window_set_title (w);
 582 }
 583
 584 gboolean
 585 psppire_window_get_unsaved (PsppireWindow *w)
 586 {
 587   return w->dirty;
 588 }
 589
 590
 591 \f
 592
 593
 594 static void
 595 minimise_window (gpointer key, gpointer value, gpointer data)
 596 {
 597   gtk_window_iconify (GTK_WINDOW (value));
 598 }
 599
 600
 601 void
 602 psppire_window_minimise_all (void)
 603 {
 604   PsppireWindowRegister *reg = psppire_window_register_new ();
 605
 606   g_hash_table_foreach (reg->name_table, minimise_window, NULL);
 607 }
 608
 609
 610 \f
 611
 612 GType
 613 psppire_window_model_get_type (void)
 614 {
 615   static GType window_model_type = 0;
 616
 617   if (! window_model_type)
 618     {
 619       static const GTypeInfo window_model_info =
 620       {
 621         sizeof (PsppireWindowIface), /* class_size */
 622         NULL,           /* base_init */
 623         NULL,           /* base_finalize */
 624         NULL,
 625         NULL,           /* class_finalize */
 626         NULL,           /* class_data */
 627         0,
 628         0,              /* n_preallocs */
 629         NULL
 630       };
 631
 632       window_model_type =
 633         g_type_register_static (G_TYPE_INTERFACE, "PsppireWindowModel",
 634                                 &window_model_info, 0);
 635
 636       g_type_interface_add_prerequisite (window_model_type, G_TYPE_OBJECT);
 637     }
 638
 639   return window_model_type;
 640 }
 641
 642
 643 void
 644 psppire_window_save (PsppireWindow *w)
 645 {
 646   PsppireWindowIface *i = PSPPIRE_WINDOW_MODEL_GET_IFACE (w);
 647
 648   g_assert (i);
 649   g_return_if_fail (i->save);
 650
 651   if (w->filename == NULL)
 652     psppire_window_save_as (w);
 653   else
 654     {
 655       i->save (w);
 656       w->dirty = FALSE;
 657       psppire_window_set_title (w);
 658     }
 659 }
 660
 661 void
 662 psppire_window_save_as (PsppireWindow *w)
 663 {
 664   PsppireWindowIface *i = PSPPIRE_WINDOW_MODEL_GET_IFACE (w);
 665   gchar *old_filename;
 666
 667   g_assert (i);
 668   g_return_if_fail (i->pick_filename);
 669
 670   old_filename = w->filename;
 671   w->filename = NULL;
 672
 673   i->pick_filename (w);
 674   if (w->filename == NULL)
 675     w->filename = old_filename;
 676   else
 677     {
 678       g_free (old_filename);
 679       psppire_window_save (w);
 680     }
 681 }
 682
 683 static void delete_recent (const char *file_name);
 684
 685 gboolean
 686 psppire_window_load (PsppireWindow *w, const gchar *file)
 687 {
 688   gboolean ok;
 689   PsppireWindowIface *i = PSPPIRE_WINDOW_MODEL_GET_IFACE (w);
 690
 691   g_assert (PSPPIRE_IS_WINDOW_MODEL (w));
 692
 693   g_assert (i);
 694
 695   g_return_val_if_fail (i->load, FALSE);
 696
 697   ok = i->load (w, file);
 698
 699   if ( ok )
 700     {
 701       psppire_window_set_filename (w, file);
 702       w->dirty = FALSE;
 703     }
 704   else
 705     delete_recent (file);
 706
 707   return ok;
 708 }
 709
 710
 711 static void
 712 on_selection_changed (GtkFileChooser *chooser, GtkWidget *encoding_selector)
 713 {
 714   const gchar *sysname;
 715
 716   const gchar *name = gtk_file_chooser_get_filename (chooser);
 717
 718   if ( NULL == name )
 719     return;
 720
 721   sysname = convert_glib_filename_to_system_filename (name, NULL);
 722
 723   if ( ! fn_exists (sysname))
 724     {
 725       gtk_widget_set_sensitive (encoding_selector, FALSE);
 726       return;
 727     }
 728
 729   gtk_widget_set_sensitive (encoding_selector, ! any_reader_may_open (sysname));
 730 }
 731
 732 GtkWidget *
 733 psppire_window_file_chooser_dialog (PsppireWindow *toplevel)
 734 {
 735   GtkFileFilter *filter = gtk_file_filter_new ();
 736   GtkWidget *dialog =
 737     gtk_file_chooser_dialog_new (_("Open"),
 738                                  GTK_WINDOW (toplevel),
 739                                  GTK_FILE_CHOOSER_ACTION_OPEN,
 740                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 741                                  GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 742                                  NULL);
 743
 744   g_object_set (dialog, "local-only", FALSE, NULL);
 745
 746   gtk_file_filter_set_name (filter, _("Data and Syntax Files"));
 747   gtk_file_filter_add_mime_type (filter, "application/x-spss-sav");
 748   gtk_file_filter_add_mime_type (filter, "application/x-spss-por");
 749   gtk_file_filter_add_pattern (filter, "*.sps");
 750   gtk_file_filter_add_pattern (filter, "*.SPS");
 751   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 752
 753   filter = gtk_file_filter_new ();
 754   gtk_file_filter_set_name (filter, _("System Files (*.sav)"));
 755   gtk_file_filter_add_mime_type (filter, "application/x-spss-sav");
 756   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 757
 758   filter = gtk_file_filter_new ();
 759   gtk_file_filter_set_name (filter, _("Portable Files (*.por) "));
 760   gtk_file_filter_add_mime_type (filter, "application/x-spss-por");
 761   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 762
 763   filter = gtk_file_filter_new ();
 764   gtk_file_filter_set_name (filter, _("Syntax Files (*.sps) "));
 765   gtk_file_filter_add_pattern (filter, "*.sps");
 766   gtk_file_filter_add_pattern (filter, "*.SPS");
 767   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 768
 769   filter = gtk_file_filter_new ();
 770   gtk_file_filter_set_name (filter, _("All Files"));
 771   gtk_file_filter_add_pattern (filter, "*");
 772   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 773
 774   if (toplevel->filename)
 775     {
 776       const gchar *filename = toplevel->filename;
 777       gchar *dir_name;
 778
 779       if ( ! g_path_is_absolute (filename))
 780         {
 781           gchar *path =
 782             g_build_filename (g_get_current_dir (), filename, NULL);
 783           dir_name = g_path_get_dirname (path);
 784           g_free (path);
 785         }
 786       else
 787         {
 788           dir_name = g_path_get_dirname (filename);
 789         }
 790       gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
 791                                            dir_name);
 792       free (dir_name);
 793     }
 794
 795
 796   {
 797     GtkWidget *encoding_selector =  psppire_encoding_selector_new ("Auto", true);
 798
 799     gtk_widget_set_sensitive (encoding_selector, FALSE);
 800
 801     g_signal_connect (dialog, "selection-changed", G_CALLBACK (on_selection_changed),
 802                       encoding_selector);
 803
 804     gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), encoding_selector);
 805   }
 806
 807   return dialog;
 808 }
 809
 810 /* Callback for the file_open action.
 811    Prompts for a filename and opens it */
 812 void
 813 psppire_window_open (PsppireWindow *de)
 814 {
 815   GtkWidget *dialog = psppire_window_file_chooser_dialog (de);
 816
 817   switch (gtk_dialog_run (GTK_DIALOG (dialog)))
 818     {
 819     case GTK_RESPONSE_ACCEPT:
 820       {
 821         gchar *name =
 822           gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 823
 824         gchar *sysname = convert_glib_filename_to_system_filename (name, NULL);
 825
 826         gchar *encoding = psppire_encoding_selector_get_encoding (
 827           gtk_file_chooser_get_extra_widget (GTK_FILE_CHOOSER (dialog)));
 828
 829         if (any_reader_may_open (sysname))
 830           open_data_window (de, name);
 831         else
 832           open_syntax_window (name, encoding);
 833
 834         g_free (encoding);
 835         g_free (sysname);
 836         g_free (name);
 837       }
 838       break;
 839     default:
 840       break;
 841     }
 842
 843   gtk_widget_destroy (dialog);
 844 }
 845
 846
 847 /* Puts FILE_NAME (encoded in the glib file name encoding) into the recent list
 848    with associated MIME_TYPE.  If it's already in the list, it moves it to the
 849    top. */
 850 void
 851 add_most_recent (const char *file_name, const char *mime_type)
 852 {
 853   gchar *uri = g_filename_to_uri  (file_name, NULL, NULL);
 854
 855   if ( uri )
 856     {
 857       GtkRecentData recent_data;
 858
 859       recent_data.display_name = NULL;
 860       recent_data.description = NULL;
 861       recent_data.mime_type = CONST_CAST (gchar *, mime_type);
 862       recent_data.app_name = CONST_CAST (gchar *, g_get_application_name ());
 863       recent_data.app_exec = g_strjoin (" ", g_get_prgname (), "%u", NULL);
 864       recent_data.groups = NULL;
 865       recent_data.is_private = FALSE;
 866
 867       gtk_recent_manager_add_full (gtk_recent_manager_get_default (),
 868                                    uri, &recent_data);
 869
 870       g_free (recent_data.app_exec);
 871     }
 872
 873   g_free (uri);
 874 }
 875
 876
 877
 878 /*
 879    If FILE_NAME exists in the recent list, then  delete it.
 880  */
 881 static void
 882 delete_recent (const char *file_name)
 883 {
 884   gchar *uri = g_filename_to_uri  (file_name, NULL, NULL);
 885
 886   if ( uri )
 887     gtk_recent_manager_remove_item (gtk_recent_manager_get_default (), uri, NULL);
 888
 889   g_free (uri);
 890 }
 891