pintos-os.org Git - pspp/blob - src/ui/gui/psppire-import-assistant.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2015, 2016, 2017, 2018, 2020  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 <gtk/gtk.h>
  20
  21 #include "data/casereader.h"
  22 #include "data/data-in.h"
  23 #include "data/data-out.h"
  24 #include "data/dictionary.h"
  25 #include "data/format-guesser.h"
  26 #include "data/format.h"
  27 #include "data/gnumeric-reader.h"
  28 #include "data/ods-reader.h"
  29 #include "data/spreadsheet-reader.h"
  30 #include "data/value-labels.h"
  31 #include "data/casereader-provider.h"
  32
  33 #include "libpspp/i18n.h"
  34 #include "libpspp/line-reader.h"
  35 #include "libpspp/message.h"
  36 #include "libpspp/hmap.h"
  37 #include "libpspp/hash-functions.h"
  38 #include "libpspp/str.h"
  39
  40 #include "builder-wrapper.h"
  41
  42 #include "psppire-data-sheet.h"
  43 #include "psppire-data-store.h"
  44 #include "psppire-dialog.h"
  45 #include "psppire-delimited-text.h"
  46 #include "psppire-dict.h"
  47 #include "psppire-encoding-selector.h"
  48 #include "psppire-import-assistant.h"
  49 #include "psppire-scanf.h"
  50 #include "psppire-spreadsheet-model.h"
  51 #include "psppire-text-file.h"
  52 #include "psppire-variable-sheet.h"
  53
  54 #include "ui/syntax-gen.h"
  55
  56 #include <gettext.h>
  57 #define _(msgid) gettext (msgid)
  58 #define N_(msgid) msgid
  59
  60 enum { MAX_LINE_LEN = 16384 }; /* Max length of an acceptable line. */
  61
  62
  63 /* Chooses a name for each column on the separators page */
  64 static void choose_column_names (PsppireImportAssistant *ia);
  65
  66 static void intro_page_create (PsppireImportAssistant *ia);
  67 static void first_line_page_create (PsppireImportAssistant *ia);
  68
  69 static void separators_page_create (PsppireImportAssistant *ia);
  70 static void formats_page_create (PsppireImportAssistant *ia);
  71
  72 static void psppire_import_assistant_init            (PsppireImportAssistant      *act);
  73 static void psppire_import_assistant_class_init      (PsppireImportAssistantClass *class);
  74
  75 G_DEFINE_TYPE (PsppireImportAssistant, psppire_import_assistant, GTK_TYPE_ASSISTANT);
  76
  77
  78 /* Properties */
  79 enum
  80   {
  81     PROP_0,
  82   };
  83
  84 static void
  85 psppire_import_assistant_set_property (GObject         *object,
  86                                        guint            prop_id,
  87                                        const GValue    *value,
  88                                        GParamSpec      *pspec)
  89 {
  90   //   PsppireImportAssistant *act = PSPPIRE_IMPORT_ASSISTANT (object);
  91
  92   switch (prop_id)
  93     {
  94     default:
  95       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  96       break;
  97     };
  98 }
  99
 100
 101 static void
 102 psppire_import_assistant_get_property (GObject    *object,
 103                                        guint            prop_id,
 104                                        GValue          *value,
 105                                        GParamSpec      *pspec)
 106 {
 107   //  PsppireImportAssistant *assistant = PSPPIRE_IMPORT_ASSISTANT (object);
 108
 109   switch (prop_id)
 110     {
 111     default:
 112       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 113       break;
 114     };
 115 }
 116
 117 static GObjectClass * parent_class = NULL;
 118
 119
 120 static void
 121 psppire_import_assistant_finalize (GObject *object)
 122 {
 123   PsppireImportAssistant *ia = PSPPIRE_IMPORT_ASSISTANT (object);
 124
 125   if (ia->spreadsheet)
 126     spreadsheet_unref (ia->spreadsheet);
 127
 128   ds_destroy (&ia->quotes);
 129
 130   dict_unref (ia->dict);
 131   dict_unref (ia->casereader_dict);
 132
 133   g_object_unref (ia->builder);
 134
 135   ia->response = -1;
 136   g_main_loop_unref (ia->main_loop);
 137
 138   if (G_OBJECT_CLASS (parent_class)->finalize)
 139     G_OBJECT_CLASS (parent_class)->finalize (object);
 140 }
 141
 142
 143 static void
 144 psppire_import_assistant_class_init (PsppireImportAssistantClass *class)
 145 {
 146   GObjectClass *object_class = G_OBJECT_CLASS (class);
 147
 148   parent_class = g_type_class_peek_parent (class);
 149
 150   object_class->set_property = psppire_import_assistant_set_property;
 151   object_class->get_property = psppire_import_assistant_get_property;
 152
 153   object_class->finalize = psppire_import_assistant_finalize;
 154 }
 155
 156
 157 /* Causes the assistant to close, returning RESPONSE for
 158    interpretation by text_data_import_assistant. */
 159 static void
 160 close_assistant (PsppireImportAssistant *ia, int response)
 161 {
 162   ia->response = response;
 163   g_main_loop_quit (ia->main_loop);
 164   gtk_widget_hide (GTK_WIDGET (ia));
 165 }
 166
 167
 168 /* Called when the Paste button on the last page of the assistant
 169    is clicked. */
 170 static void
 171 on_paste (GtkButton *button, PsppireImportAssistant *ia)
 172 {
 173   close_assistant (ia, PSPPIRE_RESPONSE_PASTE);
 174 }
 175
 176
 177 /* Revises the contents of the fields tree view based on the
 178    currently chosen set of separators. */
 179 static void
 180 revise_fields_preview (PsppireImportAssistant *ia)
 181 {
 182   choose_column_names (ia);
 183 }
 184
 185
 186 struct separator
 187 {
 188   const char *name;           /* Name (for use with get_widget_assert). */
 189   gunichar c;                 /* Separator character. */
 190 };
 191
 192 /* All the separators in the dialog box. */
 193 static const struct separator separators[] =
 194   {
 195     {"space",     ' '},
 196     {"tab",       '\t'},
 197     {"bang",      '!'},
 198     {"colon",     ':'},
 199     {"comma",     ','},
 200     {"hyphen",    '-'},
 201     {"pipe",      '|'},
 202     {"semicolon", ';'},
 203     {"slash",     '/'},
 204   };
 205
 206 #define SEPARATOR_CNT (sizeof separators / sizeof *separators)
 207
 208 struct separator_count_node
 209 {
 210   struct hmap_node node;
 211   int occurance; /* The number of times the separator occurs in a line */
 212   int quantity;  /* The number of lines with this occurance */
 213 };
 214
 215
 216 /* Picks the most likely separator and quote characters based on
 217    IA's file data. */
 218 static void
 219 choose_likely_separators (PsppireImportAssistant *ia)
 220 {
 221   gint first_line = 0;
 222   g_object_get (ia->delimiters_model, "first-line", &first_line, NULL);
 223
 224   gboolean valid;
 225   GtkTreeIter iter;
 226   int j;
 227
 228   struct hmap count_map[SEPARATOR_CNT];
 229   for (j = 0; j < SEPARATOR_CNT; ++j)
 230     hmap_init (count_map + j);
 231
 232   GtkTreePath *p = gtk_tree_path_new_from_indices (first_line, -1);
 233
 234   for (valid = gtk_tree_model_get_iter (GTK_TREE_MODEL (ia->text_file), &iter, p);
 235        valid;
 236        valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (ia->text_file), &iter))
 237     {
 238       gchar *line_text = NULL;
 239       gtk_tree_model_get (GTK_TREE_MODEL (ia->text_file), &iter, 1, &line_text, -1);
 240
 241       gint *counts = xzalloc (sizeof *counts * SEPARATOR_CNT);
 242
 243       struct substring cs = ss_cstr (line_text);
 244       for (;
 245            UINT32_MAX != ss_first_mb (cs);
 246            ss_get_mb (&cs))
 247         {
 248           ucs4_t character = ss_first_mb (cs);
 249
 250           int s;
 251           for (s = 0; s < SEPARATOR_CNT; ++s)
 252             {
 253               if (character == separators[s].c)
 254                 counts[s]++;
 255             }
 256         }
 257
 258       int j;
 259       for (j = 0; j < SEPARATOR_CNT; ++j)
 260         {
 261           if (counts[j] > 0)
 262             {
 263               struct separator_count_node *cn = NULL;
 264               unsigned int hash = hash_int (counts[j], 0);
 265               HMAP_FOR_EACH_WITH_HASH (cn, struct separator_count_node, node, hash, &count_map[j])
 266                 {
 267                   if (cn->occurance == counts[j])
 268                     break;
 269                 }
 270
 271               if (cn == NULL)
 272                 {
 273                   struct separator_count_node *new_cn = xzalloc (sizeof *new_cn);
 274                   new_cn->occurance = counts[j];
 275                   new_cn->quantity = 1;
 276                   hmap_insert (&count_map[j], &new_cn->node, hash);
 277                 }
 278               else
 279                 cn->quantity++;
 280             }
 281         }
 282
 283       free (line_text);
 284       free (counts);
 285     }
 286   gtk_tree_path_free (p);
 287
 288   if (hmap_count (count_map) > 0)
 289     {
 290       int most_frequent = -1;
 291       int largest = 0;
 292       for (j = 0; j < SEPARATOR_CNT; ++j)
 293         {
 294           struct separator_count_node *cn;
 295           HMAP_FOR_EACH (cn, struct separator_count_node, node, &count_map[j])
 296             {
 297               if (largest < cn->quantity)
 298                 {
 299                   largest = cn->quantity;
 300                   most_frequent = j;
 301                 }
 302             }
 303           hmap_destroy (&count_map[j]);
 304         }
 305
 306       g_return_if_fail (most_frequent >= 0);
 307
 308       GtkWidget *toggle =
 309         get_widget_assert (ia->builder, separators[most_frequent].name);
 310       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), TRUE);
 311     }
 312 }
 313
 314 static void
 315 repopulate_delimiter_columns (PsppireImportAssistant *ia)
 316 {
 317   /* Remove all the columns */
 318   while (gtk_tree_view_get_n_columns (GTK_TREE_VIEW (ia->fields_tree_view)) > 0)
 319     {
 320       GtkTreeViewColumn *tvc = gtk_tree_view_get_column (GTK_TREE_VIEW (ia->fields_tree_view), 0);
 321       gtk_tree_view_remove_column (GTK_TREE_VIEW (ia->fields_tree_view), tvc);
 322     }
 323
 324   gint n_fields =
 325     gtk_tree_model_get_n_columns (GTK_TREE_MODEL (ia->delimiters_model));
 326
 327   /* ... and put them back again. */
 328   gint f;
 329   for (f = gtk_tree_view_get_n_columns (GTK_TREE_VIEW (ia->fields_tree_view));
 330        f < n_fields; f++)
 331     {
 332       GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
 333
 334       const gchar *title = NULL;
 335
 336       if (f == 0)
 337         title = _("line");
 338       else
 339         {
 340           if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ia->variable_names_cb)))
 341             {
 342               title =
 343                 psppire_delimited_text_get_header_title
 344                 (PSPPIRE_DELIMITED_TEXT (ia->delimiters_model), f - 1);
 345             }
 346           if (title == NULL)
 347             title = _("var");
 348         }
 349
 350       GtkTreeViewColumn *column =
 351         gtk_tree_view_column_new_with_attributes (title,
 352                                                   renderer,
 353                                                   "text", f,
 354                                                   NULL);
 355       g_object_set (column,
 356                     "resizable", TRUE,
 357                     "sizing", GTK_TREE_VIEW_COLUMN_AUTOSIZE,
 358                     NULL);
 359
 360       gtk_tree_view_append_column (GTK_TREE_VIEW (ia->fields_tree_view), column);
 361     }
 362 }
 363
 364 static void
 365 reset_tree_view_model (PsppireImportAssistant *ia)
 366 {
 367   GtkTreeModel *tm = gtk_tree_view_get_model (GTK_TREE_VIEW (ia->fields_tree_view));
 368   g_object_ref (tm);
 369   gtk_tree_view_set_model (GTK_TREE_VIEW (ia->fields_tree_view), NULL);
 370
 371
 372   repopulate_delimiter_columns (ia);
 373
 374   gtk_tree_view_set_model (GTK_TREE_VIEW (ia->fields_tree_view), tm);
 375   //  gtk_tree_view_columns_autosize (GTK_TREE_VIEW (ia->fields_tree_view));
 376
 377   g_object_unref (tm);
 378 }
 379
 380 /* Called just before the separators page becomes visible in the
 381    assistant, and when the Reset button is clicked. */
 382 static void
 383 prepare_separators_page (PsppireImportAssistant *ia, GtkWidget *page)
 384 {
 385   gtk_tree_view_set_model (GTK_TREE_VIEW (ia->fields_tree_view),
 386                            GTK_TREE_MODEL (ia->delimiters_model));
 387
 388   g_signal_connect_swapped (GTK_TREE_MODEL (ia->delimiters_model), "notify::delimiters",
 389                         G_CALLBACK (reset_tree_view_model), ia);
 390
 391
 392   repopulate_delimiter_columns (ia);
 393
 394   revise_fields_preview (ia);
 395   choose_likely_separators (ia);
 396 }
 397
 398 /* Resets IA's intro page to its initial state. */
 399 static void
 400 reset_intro_page (PsppireImportAssistant *ia)
 401 {
 402   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ia->all_cases_button),
 403                                 TRUE);
 404 }
 405
 406
 407
 408 /* Clears the set of user-modified variables from IA's formats
 409    substructure.  This discards user modifications to variable
 410    formats, thereby causing formats to revert to their
 411    defaults.  */
 412 static void
 413 reset_formats_page (PsppireImportAssistant *ia, GtkWidget *page)
 414 {
 415 }
 416
 417 static void prepare_formats_page (PsppireImportAssistant *ia);
 418
 419 /* Called when the Reset button is clicked. */
 420 static void
 421 on_reset (GtkButton *button, PsppireImportAssistant *ia)
 422 {
 423   gint pn = gtk_assistant_get_current_page (GTK_ASSISTANT (ia));
 424   {
 425     GtkWidget *page =  gtk_assistant_get_nth_page (GTK_ASSISTANT (ia), pn);
 426
 427     page_func *on_reset = g_object_get_data (G_OBJECT (page), "on-reset");
 428
 429     if (on_reset)
 430       on_reset (ia, page);
 431   }
 432 }
 433
 434
 435 static gint
 436 next_page_func (gint old_page, gpointer data)
 437 {
 438   return old_page + 1;
 439 }
 440
 441
 442 /* Called just before PAGE is displayed as the current page of
 443    IMPORT_ASSISTANT, this updates IA content according to the new
 444    page. */
 445 static void
 446 on_prepare (GtkAssistant *assistant, GtkWidget *page, PsppireImportAssistant *ia)
 447 {
 448   gtk_widget_show (ia->reset_button);
 449   gtk_widget_hide (ia->paste_button);
 450
 451   gint pn = gtk_assistant_get_current_page (assistant);
 452   gint previous_page_index = ia->current_page;
 453
 454   if (previous_page_index >= 0)
 455     {
 456       GtkWidget *closing_page = gtk_assistant_get_nth_page (GTK_ASSISTANT (ia), previous_page_index);
 457
 458       if (pn > previous_page_index)
 459         {
 460           page_func *on_forward = g_object_get_data (G_OBJECT (closing_page), "on-forward");
 461
 462           if (on_forward)
 463             on_forward (ia, closing_page);
 464         }
 465       else
 466         {
 467           page_func *on_back = g_object_get_data (G_OBJECT (closing_page), "on-back");
 468
 469           if (on_back)
 470             on_back (ia, closing_page);
 471         }
 472     }
 473
 474   {
 475     GtkWidget *new_page = gtk_assistant_get_nth_page (GTK_ASSISTANT (ia), pn);
 476
 477     page_func *on_entering = g_object_get_data (G_OBJECT (new_page), "on-entering");
 478
 479     if (on_entering)
 480       on_entering (ia, new_page);
 481   }
 482
 483   ia->current_page = pn;
 484 }
 485
 486 /* Called when the Cancel button in the assistant is clicked. */
 487 static void
 488 on_cancel (GtkAssistant *assistant, PsppireImportAssistant *ia)
 489 {
 490   close_assistant (ia, GTK_RESPONSE_CANCEL);
 491 }
 492
 493 /* Called when the Apply button on the last page of the assistant
 494    is clicked. */
 495 static void
 496 on_close (GtkAssistant *assistant, PsppireImportAssistant *ia)
 497 {
 498   close_assistant (ia, GTK_RESPONSE_APPLY);
 499 }
 500
 501
 502 static GtkWidget *
 503 add_page_to_assistant (PsppireImportAssistant *ia,
 504                        GtkWidget *page, GtkAssistantPageType type, const gchar *);
 505
 506
 507 static void
 508 on_sheet_combo_changed (GtkComboBox *cb, PsppireImportAssistant *ia)
 509 {
 510   GtkTreeIter iter;
 511   gchar *range = NULL;
 512   GtkTreeModel *model = gtk_combo_box_get_model (cb);
 513   GtkBuilder *builder = ia->builder;
 514   GtkWidget *range_entry = get_widget_assert (builder, "cell-range-entry");
 515
 516   gtk_combo_box_get_active_iter (cb, &iter);
 517   gtk_tree_model_get (model, &iter, PSPPIRE_SPREADSHEET_MODEL_COL_RANGE, &range, -1);
 518   gtk_entry_set_text (GTK_ENTRY (range_entry), range ?  range : "");
 519   g_free (range);
 520 }
 521
 522 /* Prepares IA's sheet_spec page. */
 523 static void
 524 prepare_sheet_spec_page (PsppireImportAssistant *ia)
 525 {
 526   GtkBuilder *builder = ia->builder;
 527   GtkWidget *sheet_entry = get_widget_assert (builder, "sheet-entry");
 528   GtkWidget *readnames_checkbox = get_widget_assert (builder, "readnames-checkbox");
 529
 530   gtk_combo_box_set_model (GTK_COMBO_BOX (sheet_entry),
 531                            psppire_spreadsheet_model_new (ia->spreadsheet));
 532
 533   gtk_combo_box_set_active (GTK_COMBO_BOX (sheet_entry), 0);
 534
 535   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (readnames_checkbox), FALSE);
 536 }
 537
 538
 539 /* Initializes IA's sheet_spec substructure. */
 540 static void
 541 sheet_spec_page_create (PsppireImportAssistant *ia)
 542 {
 543   GtkBuilder *builder = ia->builder;
 544   GtkWidget *page = get_widget_assert (builder, "Spreadsheet-Importer");
 545
 546   GtkWidget *combo_box = get_widget_assert (builder, "sheet-entry");
 547   GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
 548   gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo_box));
 549   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, TRUE);
 550   gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer,
 551                                   "text", 0,
 552                                   NULL);
 553
 554   g_signal_connect (combo_box, "changed", G_CALLBACK (on_sheet_combo_changed), ia);
 555
 556   add_page_to_assistant (ia, page,
 557                          GTK_ASSISTANT_PAGE_CONTENT, _("Importing Spreadsheet Data"));
 558
 559   g_object_set_data (G_OBJECT (page), "on-entering", prepare_sheet_spec_page);
 560 }
 561
 562 static void
 563 on_chosen (PsppireImportAssistant *ia, GtkWidget *page)
 564 {
 565   GtkFileChooser *fc = GTK_FILE_CHOOSER (page);
 566   gchar *f = gtk_file_chooser_get_filename (fc);
 567   int i;
 568
 569   for(i = gtk_assistant_get_n_pages (GTK_ASSISTANT (ia)); i > 0; --i)
 570     gtk_assistant_remove_page (GTK_ASSISTANT (ia), i);
 571
 572   gtk_assistant_set_page_complete (GTK_ASSISTANT(ia), GTK_WIDGET (fc), FALSE);
 573
 574   if (f && g_file_test (f, G_FILE_TEST_IS_REGULAR))
 575     {
 576       gtk_assistant_set_page_complete (GTK_ASSISTANT(ia), GTK_WIDGET (fc), TRUE);
 577
 578       if (ia->spreadsheet)
 579         spreadsheet_unref (ia->spreadsheet);
 580
 581       ia->spreadsheet = gnumeric_probe (f, FALSE);
 582
 583       if (!ia->spreadsheet)
 584         ia->spreadsheet = ods_probe (f, FALSE);
 585
 586       if (ia->spreadsheet)
 587         {
 588           sheet_spec_page_create (ia);
 589         }
 590       else
 591         {
 592           intro_page_create (ia);
 593           first_line_page_create (ia);
 594           separators_page_create (ia);
 595         }
 596
 597       formats_page_create (ia);
 598     }
 599
 600   g_free (f);
 601 }
 602
 603 /* This has to be done on a map signal callback,
 604    because GtkFileChooserWidget resets everything when it is mapped. */
 605 static void
 606 on_map (PsppireImportAssistant *ia, GtkWidget *page)
 607 {
 608 #if TEXT_FILE
 609   GtkFileChooser *fc = GTK_FILE_CHOOSER (page);
 610
 611   if (ia->file_name)
 612     gtk_file_chooser_set_filename (fc, ia->file_name);
 613 #endif
 614
 615   on_chosen (ia, page);
 616 }
 617
 618
 619
 620 static void
 621 chooser_page_enter (PsppireImportAssistant *ia, GtkWidget *page)
 622 {
 623 }
 624
 625 static void
 626 chooser_page_leave (PsppireImportAssistant *ia, GtkWidget *page)
 627 {
 628   g_free (ia->file_name);
 629   ia->file_name = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (page));
 630   gchar *encoding = psppire_encoding_selector_get_encoding (ia->encoding_selector);
 631
 632   if (!ia->spreadsheet)
 633     {
 634       ia->text_file = psppire_text_file_new (ia->file_name, encoding);
 635       gtk_tree_view_set_model (GTK_TREE_VIEW (ia->first_line_tree_view),
 636                                GTK_TREE_MODEL (ia->text_file));
 637     }
 638
 639
 640   g_free (encoding);
 641 }
 642
 643 static void
 644 chooser_page_reset (PsppireImportAssistant *ia, GtkWidget *page)
 645 {
 646   GtkFileChooser *fc = GTK_FILE_CHOOSER (page);
 647
 648   gtk_file_chooser_set_filter (fc, ia->default_filter);
 649   gtk_file_chooser_unselect_all (fc);
 650
 651   on_chosen (ia, page);
 652 }
 653
 654
 655
 656 static void
 657 chooser_page_create (PsppireImportAssistant *ia)
 658 {
 659   GtkFileFilter *filter = NULL;
 660
 661   GtkWidget *chooser = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_OPEN);
 662
 663   g_object_set_data (G_OBJECT (chooser), "on-forward", chooser_page_leave);
 664   g_object_set_data (G_OBJECT (chooser), "on-reset",   chooser_page_reset);
 665   g_object_set_data (G_OBJECT (chooser), "on-entering",chooser_page_enter);
 666
 667   g_object_set (chooser, "local-only", FALSE, NULL);
 668
 669
 670   ia->default_filter = gtk_file_filter_new ();
 671   gtk_file_filter_set_name (ia->default_filter, _("All Files"));
 672   gtk_file_filter_add_pattern (ia->default_filter, "*");
 673   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), ia->default_filter);
 674
 675   filter = gtk_file_filter_new ();
 676   gtk_file_filter_set_name (filter, _("Text Files"));
 677   gtk_file_filter_add_mime_type (filter, "text/*");
 678   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 679
 680   filter = gtk_file_filter_new ();
 681   gtk_file_filter_set_name (filter, _("Text (*.txt) Files"));
 682   gtk_file_filter_add_pattern (filter, "*.txt");
 683   gtk_file_filter_add_pattern (filter, "*.TXT");
 684   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 685
 686   filter = gtk_file_filter_new ();
 687   gtk_file_filter_set_name (filter, _("Plain Text (ASCII) Files"));
 688   gtk_file_filter_add_mime_type (filter, "text/plain");
 689   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 690
 691   filter = gtk_file_filter_new ();
 692   gtk_file_filter_set_name (filter, _("Comma Separated Value Files"));
 693   gtk_file_filter_add_mime_type (filter, "text/csv");
 694   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 695
 696   /* I've never encountered one of these, but it's listed here:
 697      http://www.iana.org/assignments/media-types/text/tab-separated-values  */
 698   filter = gtk_file_filter_new ();
 699   gtk_file_filter_set_name (filter, _("Tab Separated Value Files"));
 700   gtk_file_filter_add_mime_type (filter, "text/tab-separated-values");
 701   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 702
 703   filter = gtk_file_filter_new ();
 704   gtk_file_filter_set_name (filter, _("Gnumeric Spreadsheet Files"));
 705   gtk_file_filter_add_mime_type (filter, "application/x-gnumeric");
 706   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 707
 708   filter = gtk_file_filter_new ();
 709   gtk_file_filter_set_name (filter, _("OpenDocument Spreadsheet Files"));
 710   gtk_file_filter_add_mime_type (filter, "application/vnd.oasis.opendocument.spreadsheet");
 711   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 712
 713   filter = gtk_file_filter_new ();
 714   gtk_file_filter_set_name (filter, _("All Spreadsheet Files"));
 715   gtk_file_filter_add_mime_type (filter, "application/x-gnumeric");
 716   gtk_file_filter_add_mime_type (filter, "application/vnd.oasis.opendocument.spreadsheet");
 717   gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
 718
 719   ia->encoding_selector = psppire_encoding_selector_new ("Auto", TRUE);
 720   gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (chooser), ia->encoding_selector);
 721
 722   add_page_to_assistant (ia, chooser,
 723                          GTK_ASSISTANT_PAGE_INTRO, _("Select File to Import"));
 724
 725   g_signal_connect_swapped (chooser, "selection-changed", G_CALLBACK (on_chosen), ia);
 726   g_signal_connect_swapped (chooser, "map", G_CALLBACK (on_map), ia);
 727 }
 728
 729
 730
 731 static void
 732 psppire_import_assistant_init (PsppireImportAssistant *ia)
 733 {
 734   ia->builder = builder_new ("text-data-import.ui");
 735
 736   ia->current_page = -1 ;
 737   ia->file_name = NULL;
 738
 739   ia->spreadsheet = NULL;
 740   ia->dict = NULL;
 741   ia->casereader_dict = NULL;
 742
 743   ia->main_loop = g_main_loop_new (NULL, TRUE);
 744
 745   g_signal_connect (ia, "prepare", G_CALLBACK (on_prepare), ia);
 746   g_signal_connect (ia, "cancel", G_CALLBACK (on_cancel), ia);
 747   g_signal_connect (ia, "close", G_CALLBACK (on_close), ia);
 748
 749   ia->paste_button = gtk_button_new_with_label (_("Paste"));
 750   ia->reset_button = gtk_button_new_with_label (_("Reset"));
 751
 752   gtk_assistant_add_action_widget (GTK_ASSISTANT(ia), ia->paste_button);
 753
 754   g_signal_connect (ia->paste_button, "clicked", G_CALLBACK (on_paste), ia);
 755   g_signal_connect (ia->reset_button, "clicked", G_CALLBACK (on_reset), ia);
 756
 757   gtk_assistant_add_action_widget (GTK_ASSISTANT(ia), ia->reset_button);
 758
 759   gtk_window_set_title (GTK_WINDOW (ia),
 760                         _("Importing Delimited Text Data"));
 761
 762   gtk_window_set_icon_name (GTK_WINDOW (ia), "pspp");
 763
 764   chooser_page_create (ia);
 765
 766   gtk_assistant_set_forward_page_func (GTK_ASSISTANT (ia), next_page_func, NULL, NULL);
 767
 768   gtk_window_maximize (GTK_WINDOW (ia));
 769 }
 770
 771
 772 /* Appends a page of the given TYPE, with PAGE as its content, to
 773    the GtkAssistant encapsulated by IA.  Returns the GtkWidget
 774    that represents the page. */
 775 static GtkWidget *
 776 add_page_to_assistant (PsppireImportAssistant *ia,
 777                        GtkWidget *page, GtkAssistantPageType type, const gchar *title)
 778 {
 779   GtkWidget *content = page;
 780
 781   gtk_assistant_append_page (GTK_ASSISTANT (ia), content);
 782   gtk_assistant_set_page_type (GTK_ASSISTANT(ia), content, type);
 783   gtk_assistant_set_page_title (GTK_ASSISTANT(ia), content, title);
 784   gtk_assistant_set_page_complete (GTK_ASSISTANT(ia), content, TRUE);
 785
 786   return content;
 787 }
 788
 789
 790 /* Called when one of the radio buttons is clicked. */
 791 static void
 792 on_intro_amount_changed (PsppireImportAssistant *p)
 793 {
 794   gtk_widget_set_sensitive (p->n_cases_spin,
 795                             gtk_toggle_button_get_active
 796                             (GTK_TOGGLE_BUTTON (p->n_cases_button)));
 797
 798   gtk_widget_set_sensitive (p->percent_spin,
 799                             gtk_toggle_button_get_active
 800                             (GTK_TOGGLE_BUTTON (p->percent_button)));
 801 }
 802
 803 static void
 804 on_treeview_selection_change (PsppireImportAssistant *ia)
 805 {
 806   GtkTreeSelection *selection =
 807     gtk_tree_view_get_selection (GTK_TREE_VIEW (ia->first_line_tree_view));
 808   GtkTreeModel *model = NULL;
 809   GtkTreeIter iter;
 810   if (gtk_tree_selection_get_selected (selection, &model, &iter))
 811     {
 812       gint max_lines;
 813       int n;
 814       GtkTreePath *path = gtk_tree_model_get_path (model, &iter);
 815       gint *index = gtk_tree_path_get_indices (path);
 816       n = *index;
 817       gtk_tree_path_free (path);
 818       g_object_get (model, "maximum-lines", &max_lines, NULL);
 819       gtk_widget_set_sensitive (ia->variable_names_cb,
 820                                 (n > 0 && n < max_lines));
 821       ia->delimiters_model =
 822         psppire_delimited_text_new (GTK_TREE_MODEL (ia->text_file));
 823       g_object_set (ia->delimiters_model, "first-line", n, NULL);
 824     }
 825 }
 826
 827 static void
 828 render_text_preview_line (GtkTreeViewColumn *tree_column,
 829                 GtkCellRenderer *cell,
 830                 GtkTreeModel *tree_model,
 831                 GtkTreeIter *iter,
 832                 gpointer data)
 833 {
 834   /*
 835      Set the text  to a "insensitive" state if the row
 836      is greater than what the user declared to be the maximum.
 837   */
 838   GtkTreePath *path = gtk_tree_model_get_path (tree_model, iter);
 839   gint *ii = gtk_tree_path_get_indices (path);
 840   gint max_lines;
 841   g_object_get (tree_model, "maximum-lines", &max_lines, NULL);
 842   g_object_set (cell, "sensitive", (*ii < max_lines), NULL);
 843   gtk_tree_path_free (path);
 844 }
 845
 846 /* Initializes IA's first_line substructure. */
 847 static void
 848 first_line_page_create (PsppireImportAssistant *ia)
 849 {
 850   GtkWidget *w =  get_widget_assert (ia->builder, "FirstLine");
 851
 852   g_object_set_data (G_OBJECT (w), "on-entering", on_treeview_selection_change);
 853
 854   add_page_to_assistant (ia, w,
 855                          GTK_ASSISTANT_PAGE_CONTENT, _("Select the First Line"));
 856
 857   GtkWidget *scrolled_window = get_widget_assert (ia->builder, "first-line-scroller");
 858
 859   if (ia->first_line_tree_view == NULL)
 860     {
 861       ia->first_line_tree_view = gtk_tree_view_new ();
 862       g_object_set (ia->first_line_tree_view, "enable-search", FALSE, NULL);
 863
 864       gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (ia->first_line_tree_view), TRUE);
 865
 866       GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
 867       GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes (_("Line"), renderer,
 868                                                                             "text", 0,
 869                                                                             NULL);
 870
 871       gtk_tree_view_column_set_cell_data_func (column, renderer, render_text_preview_line, ia, 0);
 872       gtk_tree_view_append_column (GTK_TREE_VIEW (ia->first_line_tree_view), column);
 873
 874       renderer = gtk_cell_renderer_text_new ();
 875       column = gtk_tree_view_column_new_with_attributes (_("Text"), renderer, "text", 1, NULL);
 876       gtk_tree_view_column_set_cell_data_func (column, renderer, render_text_preview_line, ia, 0);
 877
 878       gtk_tree_view_append_column (GTK_TREE_VIEW (ia->first_line_tree_view), column);
 879
 880       g_signal_connect_swapped (ia->first_line_tree_view, "cursor-changed",
 881                                 G_CALLBACK (on_treeview_selection_change), ia);
 882       gtk_container_add (GTK_CONTAINER (scrolled_window), ia->first_line_tree_view);
 883     }
 884
 885   gtk_widget_show_all (scrolled_window);
 886
 887   ia->variable_names_cb = get_widget_assert (ia->builder, "variable-names");
 888 }
 889
 890 static void
 891 intro_on_leave (PsppireImportAssistant *ia)
 892 {
 893   gint lc = 0;
 894   g_object_get (ia->text_file, "line-count", &lc, NULL);
 895   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ia->n_cases_button)))
 896     {
 897       gint max_lines = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (ia->n_cases_spin));
 898       g_object_set (ia->text_file, "maximum-lines", max_lines, NULL);
 899     }
 900   else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ia->percent_button)))
 901     {
 902       gdouble percent = gtk_spin_button_get_value (GTK_SPIN_BUTTON (ia->percent_spin));
 903       g_object_set (ia->text_file, "maximum-lines", (gint) (lc * percent / 100.0), NULL);
 904     }
 905   else
 906     {
 907       g_object_set (ia->text_file, "maximum-lines", lc, NULL);
 908     }
 909 }
 910
 911
 912 static void
 913 intro_on_enter (PsppireImportAssistant *ia)
 914 {
 915   GtkBuilder *builder = ia->builder;
 916   GtkWidget *table  = get_widget_assert (builder, "button-table");
 917
 918   struct string s;
 919
 920   ds_init_empty (&s);
 921   ds_put_cstr (&s, _("This assistant will guide you through the process of "
 922                      "importing data into PSPP from a text file with one line "
 923                      "per case,  in which fields are separated by tabs, "
 924                      "commas, or other delimiters.\n\n"));
 925
 926   if (ia->text_file)
 927     {
 928       if (ia->text_file->total_is_exact)
 929         {
 930           ds_put_format (
 931                          &s, ngettext ("The selected file contains %'lu line of text.  ",
 932                                        "The selected file contains %'lu lines of text.  ",
 933                                        ia->text_file->total_lines),
 934                          ia->text_file->total_lines);
 935         }
 936       else if (ia->text_file->total_lines > 0)
 937         {
 938           ds_put_format (
 939                          &s, ngettext (
 940                                        "The selected file contains approximately %'lu line of text.  ",
 941                                        "The selected file contains approximately %'lu lines of text.  ",
 942                                        ia->text_file->total_lines),
 943                          ia->text_file->total_lines);
 944           ds_put_format (
 945                          &s, ngettext (
 946                                        "Only the first %zu line of the file will be shown for "
 947                                        "preview purposes in the following screens.  ",
 948                                        "Only the first %zu lines of the file will be shown for "
 949                                        "preview purposes in the following screens.  ",
 950                                        ia->text_file->line_cnt),
 951                          ia->text_file->line_cnt);
 952         }
 953     }
 954
 955   ds_put_cstr (&s, _("You may choose below how much of the file should "
 956                      "actually be imported."));
 957
 958   gtk_label_set_text (GTK_LABEL (get_widget_assert (builder, "intro-label")),
 959                       ds_cstr (&s));
 960   ds_destroy (&s);
 961
 962   if (gtk_grid_get_child_at (GTK_GRID (table), 1, 1) == NULL)
 963     {
 964       GtkWidget *hbox_n_cases = psppire_scanf_new (_("Only the first %4d cases"), &ia->n_cases_spin);
 965       gtk_grid_attach (GTK_GRID (table), hbox_n_cases,
 966                        1, 1,
 967                        1, 1);
 968     }
 969
 970   GtkAdjustment *adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (ia->n_cases_spin));
 971   gtk_adjustment_set_lower (adj, 1.0);
 972
 973   if (gtk_grid_get_child_at (GTK_GRID (table), 1, 2) == NULL)
 974     {
 975       GtkWidget *hbox_percent = psppire_scanf_new (_("Only the first %3d %% of file (approximately)"),
 976                                                    &ia->percent_spin);
 977
 978       gtk_grid_attach (GTK_GRID (table), hbox_percent,
 979                        1, 2,
 980                        1, 1);
 981     }
 982
 983   gtk_widget_show_all (table);
 984
 985   on_intro_amount_changed (ia);
 986 }
 987
 988 /* Initializes IA's intro substructure. */
 989 static void
 990 intro_page_create (PsppireImportAssistant *ia)
 991 {
 992   GtkBuilder *builder = ia->builder;
 993
 994   GtkWidget *w =  get_widget_assert (builder, "Intro");
 995
 996   ia->percent_spin = gtk_spin_button_new_with_range (0, 100, 10);
 997
 998
 999   add_page_to_assistant (ia, w,  GTK_ASSISTANT_PAGE_CONTENT, _("Select the Lines to Import"));
1000
1001   ia->all_cases_button = get_widget_assert (builder, "import-all-cases");
1002
1003   ia->n_cases_button = get_widget_assert (builder, "import-n-cases");
1004
1005   ia->percent_button = get_widget_assert (builder, "import-percent");
1006
1007   g_signal_connect_swapped (ia->all_cases_button, "toggled",
1008                             G_CALLBACK (on_intro_amount_changed), ia);
1009   g_signal_connect_swapped (ia->n_cases_button, "toggled",
1010                             G_CALLBACK (on_intro_amount_changed), ia);
1011   g_signal_connect_swapped (ia->percent_button, "toggled",
1012                             G_CALLBACK (on_intro_amount_changed), ia);
1013
1014
1015   g_object_set_data (G_OBJECT (w), "on-forward", intro_on_leave);
1016   g_object_set_data (G_OBJECT (w), "on-entering", intro_on_enter);
1017   g_object_set_data (G_OBJECT (w), "on-reset", reset_intro_page);
1018 }
1019
1020
1021 GtkWidget *
1022 psppire_import_assistant_new (GtkWindow *toplevel)
1023 {
1024   return GTK_WIDGET (g_object_new (PSPPIRE_TYPE_IMPORT_ASSISTANT,
1025                                    /* Some window managers (notably ratpoison)
1026                                       ignore the maximise command when a window is
1027                                       transient.  This causes problems for this
1028                                       window. */
1029                                    /* "transient-for", toplevel, */
1030                                    NULL));
1031 }
1032
1033
1034
1035 \f
1036
1037 /* Chooses a name for each column on the separators page */
1038 static void
1039 choose_column_names (PsppireImportAssistant *ia)
1040 {
1041   int i;
1042   unsigned long int generated_name_count = 0;
1043   dict_clear (ia->dict);
1044
1045   for (i = 0;
1046        i < gtk_tree_model_get_n_columns (GTK_TREE_MODEL (ia->delimiters_model)) - 1;
1047        ++i)
1048     {
1049       const gchar *candidate_name = NULL;
1050
1051       if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ia->variable_names_cb)))
1052         {
1053           candidate_name = psppire_delimited_text_get_header_title (PSPPIRE_DELIMITED_TEXT (ia->delimiters_model), i);
1054         }
1055
1056       char *name = dict_make_unique_var_name (ia->dict,
1057                                               candidate_name,
1058                                               &generated_name_count);
1059
1060       dict_create_var_assert (ia->dict, name, 0);
1061       free (name);
1062     }
1063 }
1064
1065 /* Called when the user toggles one of the separators
1066    checkboxes. */
1067 static void
1068 on_separator_toggle (GtkToggleButton *toggle UNUSED,
1069                      PsppireImportAssistant *ia)
1070 {
1071   int i;
1072   GSList *delimiters = NULL;
1073   for (i = 0; i < SEPARATOR_CNT; i++)
1074     {
1075       const struct separator *s = &separators[i];
1076       GtkWidget *button = get_widget_assert (ia->builder, s->name);
1077       if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
1078         {
1079           delimiters = g_slist_prepend (delimiters,  GINT_TO_POINTER (s->c));
1080         }
1081     }
1082
1083   g_object_set (ia->delimiters_model, "delimiters", delimiters, NULL);
1084
1085   revise_fields_preview (ia);
1086 }
1087
1088
1089 /* Called when the user changes the entry field for custom
1090    separators. */
1091 static void
1092 on_separators_custom_entry_notify (GObject *gobject UNUSED,
1093                                    GParamSpec *arg1 UNUSED,
1094                                    PsppireImportAssistant *ia)
1095 {
1096   revise_fields_preview (ia);
1097 }
1098
1099 /* Called when the user toggles the checkbox that enables custom
1100    separators. */
1101 static void
1102 on_separators_custom_cb_toggle (GtkToggleButton *custom_cb,
1103                                 PsppireImportAssistant *ia)
1104 {
1105   bool is_active = gtk_toggle_button_get_active (custom_cb);
1106   gtk_widget_set_sensitive (ia->custom_entry, is_active);
1107   revise_fields_preview (ia);
1108 }
1109
1110 /* Called when the user changes the selection in the combo box
1111    that selects a quote character. */
1112 static void
1113 on_quote_combo_change (GtkComboBox *combo, PsppireImportAssistant *ia)
1114 {
1115   //  revise_fields_preview (ia);
1116 }
1117
1118 /* Called when the user toggles the checkbox that enables
1119    quoting. */
1120 static void
1121 on_quote_cb_toggle (GtkToggleButton *quote_cb, PsppireImportAssistant *ia)
1122 {
1123   bool is_active = gtk_toggle_button_get_active (quote_cb);
1124   gtk_widget_set_sensitive (ia->quote_combo, is_active);
1125   revise_fields_preview (ia);
1126 }
1127
1128 /* Initializes IA's separators substructure. */
1129 static void
1130 separators_page_create (PsppireImportAssistant *ia)
1131 {
1132   GtkBuilder *builder = ia->builder;
1133
1134   size_t i;
1135
1136   GtkWidget *w = get_widget_assert (builder, "Separators");
1137
1138   g_object_set_data (G_OBJECT (w), "on-entering", prepare_separators_page);
1139   g_object_set_data (G_OBJECT (w), "on-reset", prepare_separators_page);
1140
1141   add_page_to_assistant (ia, w,   GTK_ASSISTANT_PAGE_CONTENT, _("Choose Separators"));
1142
1143   ia->custom_cb = get_widget_assert (builder, "custom-cb");
1144   ia->custom_entry = get_widget_assert (builder, "custom-entry");
1145   ia->quote_combo = get_widget_assert (builder, "quote-combo");
1146   ia->quote_cb = get_widget_assert (builder, "quote-cb");
1147
1148   gtk_combo_box_set_active (GTK_COMBO_BOX (ia->quote_combo), 0);
1149
1150   if (ia->fields_tree_view == NULL)
1151     {
1152       GtkWidget *scroller = get_widget_assert (ia->builder, "fields-scroller");
1153       ia->fields_tree_view = gtk_tree_view_new ();
1154       g_object_set (ia->fields_tree_view, "enable-search", FALSE, NULL);
1155       gtk_container_add (GTK_CONTAINER (scroller), GTK_WIDGET (ia->fields_tree_view));
1156       gtk_widget_show_all (scroller);
1157     }
1158
1159   g_signal_connect (ia->quote_combo, "changed",
1160                     G_CALLBACK (on_quote_combo_change), ia);
1161   g_signal_connect (ia->quote_cb, "toggled",
1162                     G_CALLBACK (on_quote_cb_toggle), ia);
1163   g_signal_connect (ia->custom_entry, "notify::text",
1164                     G_CALLBACK (on_separators_custom_entry_notify), ia);
1165   g_signal_connect (ia->custom_cb, "toggled",
1166                     G_CALLBACK (on_separators_custom_cb_toggle), ia);
1167   for (i = 0; i < SEPARATOR_CNT; i++)
1168     g_signal_connect (get_widget_assert (builder, separators[i].name),
1169                       "toggled", G_CALLBACK (on_separator_toggle), ia);
1170
1171 }
1172
1173
1174
1175 \f
1176
1177
1178 static struct casereader_random_class my_casereader_class;
1179
1180 static struct ccase *
1181 my_read (struct casereader *reader, void *aux, casenumber idx)
1182 {
1183   PsppireImportAssistant *ia = PSPPIRE_IMPORT_ASSISTANT (aux);
1184   GtkTreeModel *tm = GTK_TREE_MODEL (ia->delimiters_model);
1185
1186   GtkTreePath *tp = gtk_tree_path_new_from_indices (idx, -1);
1187
1188   const struct caseproto *proto = casereader_get_proto (reader);
1189
1190   GtkTreeIter iter;
1191   struct ccase *c = NULL;
1192   if (gtk_tree_model_get_iter (tm, &iter, tp))
1193     {
1194       c = case_create (proto);
1195       int i;
1196       for (i = 0 ; i < caseproto_get_n_widths (proto); ++i)
1197         {
1198           GValue value = {0};
1199           gtk_tree_model_get_value (tm, &iter, i + 1, &value);
1200
1201           const struct variable *var = dict_get_var (ia->casereader_dict, i);
1202
1203           const gchar *ss = g_value_get_string (&value);
1204           if (ss)
1205             {
1206               union value *v = case_data_rw (c, var);
1207               /* In this reader we derive the union value from the
1208                  string in the tree_model. We retrieve the width and format
1209                  from a dictionary which is stored directly after
1210                  the reader creation. Changes in ia->dict in the
1211                  variable window are not reflected here and therefore
1212                  this is always compatible with the width in the
1213                  caseproto. See bug #58298 */
1214               char *xx = data_in (ss_cstr (ss),
1215                                   "UTF-8",
1216                                   var_get_write_format (var)->type,
1217                                   v, var_get_width (var), "UTF-8");
1218
1219               /* if (xx) */
1220               /*   g_print ("%s:%d Err %s\n", __FILE__, __LINE__, xx); */
1221               free (xx);
1222             }
1223           g_value_unset (&value);
1224         }
1225     }
1226
1227   gtk_tree_path_free (tp);
1228
1229   return c;
1230 }
1231
1232 static void
1233 my_destroy (struct casereader *reader, void *aux)
1234 {
1235   g_print ("%s:%d %p\n", __FILE__, __LINE__, reader);
1236 }
1237
1238 static void
1239 my_advance (struct casereader *reader, void *aux, casenumber cnt)
1240 {
1241   g_print ("%s:%d\n", __FILE__, __LINE__);
1242 }
1243
1244 static struct casereader *
1245 textfile_create_reader (PsppireImportAssistant *ia)
1246 {
1247   int n_vars = dict_get_var_cnt (ia->dict);
1248
1249   int i;
1250
1251   struct fmt_guesser **fg = XCALLOC (n_vars,  struct fmt_guesser *);
1252   for (i = 0 ; i < n_vars; ++i)
1253     {
1254       fg[i] = fmt_guesser_create ();
1255     }
1256
1257   gint n_rows = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (ia->delimiters_model), NULL);
1258
1259   GtkTreeIter iter;
1260   gboolean ok;
1261   for (ok = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (ia->delimiters_model), &iter);
1262        ok;
1263        ok = gtk_tree_model_iter_next (GTK_TREE_MODEL (ia->delimiters_model), &iter))
1264     {
1265       for (i = 0 ; i < n_vars; ++i)
1266         {
1267           gchar *s = NULL;
1268           gtk_tree_model_get (GTK_TREE_MODEL (ia->delimiters_model), &iter, i+1, &s, -1);
1269           if (s)
1270             fmt_guesser_add (fg[i], ss_cstr (s));
1271           free (s);
1272         }
1273     }
1274
1275   struct caseproto *proto = caseproto_create ();
1276   for (i = 0 ; i < n_vars; ++i)
1277     {
1278       struct fmt_spec fs;
1279       fmt_guesser_guess (fg[i], &fs);
1280
1281       fmt_fix (&fs, FMT_FOR_INPUT);
1282
1283       struct variable *var = dict_get_var (ia->dict, i);
1284
1285       int width = fmt_var_width (&fs);
1286
1287       var_set_width_and_formats (var, width,
1288                                  &fs, &fs);
1289
1290       proto = caseproto_add_width (proto, width);
1291       fmt_guesser_destroy (fg[i]);
1292     }
1293
1294   free (fg);
1295
1296   struct casereader *cr = casereader_create_random (proto, n_rows, &my_casereader_class,  ia);
1297   /* Store the dictionary at this point when the casereader is created.
1298      my_read depends on the dictionary to interpret the strings in the treeview.
1299      This guarantees that the union value is produced according to the
1300      caseproto in the reader. */
1301   ia->casereader_dict = dict_clone (ia->dict);
1302   caseproto_unref (proto);
1303   return cr;
1304 }
1305
1306 /* When during import the variable type is changed, the reader is reinitialized
1307    based on the new dictionary with a fresh caseprototype. The default behaviour
1308    when a variable type is changed and the column is resized is that the union
1309    value is interpreted with new variable type and an overlay for that column
1310    is generated. Here we reinit to the original reader based on strings.
1311    As a result you can switch from string to numeric to string without loosing
1312    the string information. */
1313 static void
1314 ia_variable_changed_cb (GObject *obj, gint var_num, guint what,
1315                         const struct variable *oldvar, gpointer data)
1316 {
1317   PsppireImportAssistant *ia  = PSPPIRE_IMPORT_ASSISTANT (data);
1318
1319   struct caseproto *proto = caseproto_create();
1320   for (int i = 0; i < dict_get_var_cnt (ia->dict); i++)
1321     {
1322       const struct variable *var = dict_get_var (ia->dict, i);
1323       int width = var_get_width (var);
1324       proto = caseproto_add_width (proto, width);
1325     }
1326
1327   gint n_rows = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (ia->delimiters_model), NULL);
1328
1329   PsppireDataStore *store = NULL;
1330   g_object_get (ia->data_sheet, "data-model", &store, NULL);
1331
1332   struct casereader *cr = casereader_create_random (proto, n_rows,
1333                                                     &my_casereader_class, ia);
1334   psppire_data_store_set_reader (store, cr);
1335   dict_unref (ia->casereader_dict);
1336   ia->casereader_dict = dict_clone (ia->dict);
1337 }
1338
1339 /* Called just before the formats page of the assistant is
1340    displayed. */
1341 static void
1342 prepare_formats_page (PsppireImportAssistant *ia)
1343 {
1344   my_casereader_class.read = my_read;
1345   my_casereader_class.destroy = my_destroy;
1346   my_casereader_class.advance = my_advance;
1347
1348   if (ia->spreadsheet)
1349     {
1350       GtkBuilder *builder = ia->builder;
1351       GtkWidget *range_entry = get_widget_assert (builder, "cell-range-entry");
1352       GtkWidget *rnc = get_widget_assert (builder, "readnames-checkbox");
1353       GtkWidget *combo_box = get_widget_assert (builder, "sheet-entry");
1354
1355       struct spreadsheet_read_options opts;
1356       opts.sheet_name = NULL;
1357       opts.sheet_index = gtk_combo_box_get_active (GTK_COMBO_BOX (combo_box)) + 1;
1358       opts.read_names = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (rnc));
1359       opts.cell_range = g_strdup (gtk_entry_get_text (GTK_ENTRY (range_entry)));
1360       opts.asw = 8;
1361
1362       struct casereader *reader = spreadsheet_make_reader (ia->spreadsheet, &opts);
1363
1364       PsppireDict *dict = psppire_dict_new_from_dict (ia->spreadsheet->dict);
1365       PsppireDataStore *store = psppire_data_store_new (dict);
1366       psppire_data_store_set_reader (store, reader);
1367       g_object_set (ia->data_sheet, "data-model", store, NULL);
1368       g_object_set (ia->var_sheet, "data-model", dict, NULL);
1369     }
1370   else
1371     {
1372       struct casereader *reader = textfile_create_reader (ia);
1373
1374       PsppireDict *dict = psppire_dict_new_from_dict (ia->dict);
1375       PsppireDataStore *store = psppire_data_store_new (dict);
1376       psppire_data_store_set_reader (store, reader);
1377       g_signal_connect (dict, "variable-changed",
1378                         G_CALLBACK (ia_variable_changed_cb),
1379                         ia);
1380
1381       g_object_set (ia->data_sheet, "data-model", store, NULL);
1382       g_object_set (ia->var_sheet, "data-model", dict, NULL);
1383     }
1384
1385   gint pmax;
1386   g_object_get (get_widget_assert (ia->builder, "vpaned1"),
1387                 "max-position", &pmax, NULL);
1388
1389
1390   g_object_set (get_widget_assert (ia->builder, "vpaned1"),
1391                 "position", pmax / 2, NULL);
1392
1393   gtk_widget_show (ia->paste_button);
1394 }
1395
1396 static void
1397 formats_page_create (PsppireImportAssistant *ia)
1398 {
1399   GtkBuilder *builder = ia->builder;
1400
1401   GtkWidget *w = get_widget_assert (builder, "Formats");
1402   g_object_set_data (G_OBJECT (w), "on-entering", prepare_formats_page);
1403   g_object_set_data (G_OBJECT (w), "on-reset", reset_formats_page);
1404
1405   GtkWidget *vars_scroller = get_widget_assert (builder, "vars-scroller");
1406   if (ia->var_sheet == NULL)
1407     {
1408       ia->var_sheet = psppire_variable_sheet_new ();
1409
1410       gtk_container_add (GTK_CONTAINER (vars_scroller), ia->var_sheet);
1411
1412       ia->dict = dict_create (get_default_encoding ());
1413
1414       gtk_widget_show_all (vars_scroller);
1415     }
1416   GtkWidget *data_scroller = get_widget_assert (builder, "data-scroller");
1417   if (ia->data_sheet == NULL)
1418     {
1419       ia->data_sheet = psppire_data_sheet_new ();
1420       g_object_set (ia->data_sheet, "editable", FALSE, NULL);
1421
1422       gtk_container_add (GTK_CONTAINER (data_scroller), ia->data_sheet);
1423
1424       gtk_widget_show_all (data_scroller);
1425     }
1426
1427   add_page_to_assistant (ia, w,
1428                          GTK_ASSISTANT_PAGE_CONFIRM, _("Adjust Variable Formats"));
1429 }
1430
1431
1432 \f
1433
1434 static void
1435 separators_append_syntax (const PsppireImportAssistant *ia, struct string *s)
1436 {
1437   int i;
1438
1439   ds_put_cstr (s, "  /DELIMITERS=\"");
1440
1441   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (get_widget_assert (ia->builder, "tab"))))
1442     ds_put_cstr (s, "\\t");
1443   for (i = 0; i < SEPARATOR_CNT; i++)
1444     {
1445       const struct separator *seps = &separators[i];
1446       GtkWidget *button = get_widget_assert (ia->builder, seps->name);
1447       if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
1448         {
1449           if (seps->c == '\t')
1450             continue;
1451
1452           ds_put_byte (s, seps->c);
1453         }
1454     }
1455   ds_put_cstr (s, "\"\n");
1456
1457   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ia->quote_cb)))
1458     {
1459       GtkComboBoxText *cbt = GTK_COMBO_BOX_TEXT (ia->quote_combo);
1460       gchar *quotes = gtk_combo_box_text_get_active_text (cbt);
1461       if (quotes && *quotes)
1462         syntax_gen_pspp (s, "  /QUALIFIER=%sq\n", quotes);
1463       free (quotes);
1464     }
1465 }
1466
1467 static void
1468 formats_append_syntax (const PsppireImportAssistant *ia, struct string *s)
1469 {
1470   int i;
1471   int var_cnt;
1472
1473   g_return_if_fail (ia->dict);
1474
1475   ds_put_cstr (s, "  /VARIABLES=\n");
1476
1477   var_cnt = dict_get_var_cnt (ia->dict);
1478   for (i = 0; i < var_cnt; i++)
1479     {
1480       struct variable *var = dict_get_var (ia->dict, i);
1481       char format_string[FMT_STRING_LEN_MAX + 1];
1482       fmt_to_string (var_get_print_format (var), format_string);
1483       ds_put_format (s, "    %s %s%s\n",
1484                      var_get_name (var), format_string,
1485                      i == var_cnt - 1 ? "." : "");
1486     }
1487 }
1488
1489 static void
1490 first_line_append_syntax (const PsppireImportAssistant *ia, struct string *s)
1491 {
1492   gint first_case = 0;
1493   g_object_get (ia->delimiters_model, "first-line", &first_case, NULL);
1494
1495   if (first_case > 0)
1496     ds_put_format (s, "  /FIRSTCASE=%d\n", first_case + 1);
1497 }
1498
1499 static void
1500 intro_append_syntax (const PsppireImportAssistant *ia, struct string *s)
1501 {
1502   gint first_line = 0;
1503   g_object_get (ia->delimiters_model, "first-line", &first_line, NULL);
1504
1505   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ia->n_cases_button)))
1506     ds_put_format (s, "SELECT IF ($CASENUM <= %d).\n",
1507                    gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (ia->n_cases_spin)) - first_line);
1508   else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ia->percent_button)))
1509     ds_put_format (s, "SAMPLE %.4g.\n",
1510                    gtk_spin_button_get_value (GTK_SPIN_BUTTON (ia->percent_spin)) / 100.0);
1511 }
1512
1513
1514 /* Emits PSPP syntax to S that applies the dictionary attributes
1515    (such as missing values and value labels) of the variables in
1516    DICT.  */
1517 static void
1518 apply_dict (const struct dictionary *dict, struct string *s)
1519 {
1520   size_t var_cnt = dict_get_var_cnt (dict);
1521   size_t i;
1522
1523   for (i = 0; i < var_cnt; i++)
1524     {
1525       struct variable *var = dict_get_var (dict, i);
1526       const char *name = var_get_name (var);
1527       enum val_type type = var_get_type (var);
1528       int width = var_get_width (var);
1529       enum measure measure = var_get_measure (var);
1530       enum var_role role = var_get_role (var);
1531       enum alignment alignment = var_get_alignment (var);
1532       const struct fmt_spec *format = var_get_print_format (var);
1533
1534       if (var_has_missing_values (var))
1535         {
1536           const struct missing_values *mv = var_get_missing_values (var);
1537           size_t j;
1538
1539           syntax_gen_pspp (s, "MISSING VALUES %ss (", name);
1540           for (j = 0; j < mv_n_values (mv); j++)
1541             {
1542               if (j)
1543                 ds_put_cstr (s, ", ");
1544               syntax_gen_value (s, mv_get_value (mv, j), width, format);
1545             }
1546
1547           if (mv_has_range (mv))
1548             {
1549               double low, high;
1550               if (mv_has_value (mv))
1551                 ds_put_cstr (s, ", ");
1552               mv_get_range (mv, &low, &high);
1553               syntax_gen_num_range (s, low, high, format);
1554             }
1555           ds_put_cstr (s, ").\n");
1556         }
1557       if (var_has_value_labels (var))
1558         {
1559           const struct val_labs *vls = var_get_value_labels (var);
1560           const struct val_lab **labels = val_labs_sorted (vls);
1561           size_t n_labels = val_labs_count (vls);
1562           size_t i;
1563
1564           syntax_gen_pspp (s, "VALUE LABELS %ss", name);
1565           for (i = 0; i < n_labels; i++)
1566             {
1567               const struct val_lab *vl = labels[i];
1568               ds_put_cstr (s, "\n  ");
1569               syntax_gen_value (s, &vl->value, width, format);
1570               ds_put_byte (s, ' ');
1571               syntax_gen_string (s, ss_cstr (val_lab_get_escaped_label (vl)));
1572             }
1573           free (labels);
1574           ds_put_cstr (s, ".\n");
1575         }
1576       if (var_has_label (var))
1577         syntax_gen_pspp (s, "VARIABLE LABELS %ss %sq.\n",
1578                          name, var_get_label (var));
1579       if (measure != var_default_measure (type))
1580         syntax_gen_pspp (s, "VARIABLE LEVEL %ss (%ss).\n",
1581                          name, measure_to_syntax (measure));
1582       if (role != ROLE_INPUT)
1583         syntax_gen_pspp (s, "VARIABLE ROLE /%ss %ss.\n",
1584                          var_role_to_syntax (role), name);
1585       if (alignment != var_default_alignment (type))
1586         syntax_gen_pspp (s, "VARIABLE ALIGNMENT %ss (%ss).\n",
1587                          name, alignment_to_syntax (alignment));
1588       if (var_get_display_width (var) != var_default_display_width (width))
1589         syntax_gen_pspp (s, "VARIABLE WIDTH %ss (%d).\n",
1590                          name, var_get_display_width (var));
1591     }
1592 }
1593
1594
1595
1596 static void
1597 sheet_spec_gen_syntax (PsppireImportAssistant *ia, struct string *s)
1598 {
1599   GtkBuilder *builder = ia->builder;
1600   GtkWidget *range_entry = get_widget_assert (builder, "cell-range-entry");
1601   GtkWidget *sheet_entry = get_widget_assert (builder, "sheet-entry");
1602   GtkWidget *rnc = get_widget_assert (builder, "readnames-checkbox");
1603   const gchar *range = gtk_entry_get_text (GTK_ENTRY (range_entry));
1604   int sheet_index = 1 + gtk_combo_box_get_active (GTK_COMBO_BOX (sheet_entry));
1605   gboolean read_names = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (rnc));
1606
1607
1608   char *filename;
1609   if (ia->spreadsheet)
1610     filename = ia->spreadsheet->file_name;
1611   else
1612     g_object_get (ia->text_file, "file-name", &filename, NULL);
1613   syntax_gen_pspp (s,
1614                    "GET DATA"
1615                    "\n  /TYPE=%ss"
1616                    "\n  /FILE=%sq"
1617                    "\n  /SHEET=index %d"
1618                    "\n  /READNAMES=%ss",
1619                    (ia->spreadsheet->type == SPREADSHEET_GNUMERIC) ? "GNM" : "ODS",
1620                    filename,
1621                    sheet_index,
1622                    read_names ? "ON" : "OFF");
1623
1624   if (range && 0 != strcmp ("", range))
1625     {
1626       syntax_gen_pspp (s,
1627                        "\n  /CELLRANGE=RANGE %sq", range);
1628     }
1629   else
1630     {
1631       syntax_gen_pspp (s,
1632                        "\n  /CELLRANGE=FULL");
1633     }
1634
1635
1636   syntax_gen_pspp (s, ".\n");
1637 }
1638
1639
1640 gchar *
1641 psppire_import_assistant_generate_syntax (PsppireImportAssistant *ia)
1642 {
1643   struct string s = DS_EMPTY_INITIALIZER;
1644
1645   if (!ia->spreadsheet)
1646     {
1647       gchar *file_name = NULL;
1648       gchar *encoding = NULL;
1649       g_object_get (ia->text_file,
1650                     "file-name", &file_name,
1651                     "encoding", &encoding,
1652                     NULL);
1653
1654       if (file_name == NULL)
1655         return NULL;
1656
1657       syntax_gen_pspp (&s,
1658                        "GET DATA"
1659                        "\n  /TYPE=TXT"
1660                        "\n  /FILE=%sq\n",
1661                        file_name);
1662       if (encoding && strcmp (encoding, "Auto"))
1663         syntax_gen_pspp (&s, "  /ENCODING=%sq\n", encoding);
1664
1665       ds_put_cstr (&s,
1666                    "  /ARRANGEMENT=DELIMITED\n"
1667                    "  /DELCASE=LINE\n");
1668
1669       first_line_append_syntax (ia, &s);
1670       separators_append_syntax (ia, &s);
1671
1672       formats_append_syntax (ia, &s);
1673       apply_dict (ia->dict, &s);
1674       intro_append_syntax (ia, &s);
1675     }
1676   else
1677     {
1678       sheet_spec_gen_syntax (ia, &s);
1679     }
1680
1681   return ds_cstr (&s);
1682 }
1683
1684
1685 int
1686 psppire_import_assistant_run (PsppireImportAssistant *asst)
1687 {
1688   g_main_loop_run (asst->main_loop);
1689   return asst->response;
1690 }