pintos-os.org Git - pspp/blob - src/ui/gui/page-separators.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2008, 2009, 2010, 2011, 2012, 2013  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 "ui/gui/text-data-import-dialog.h"
  20
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <gtk-contrib/psppire-sheet.h>
  24 #include <gtk/gtk.h>
  25 #include <limits.h>
  26 #include <stdlib.h>
  27 #include <sys/stat.h>
  28
  29 #include "data/data-in.h"
  30 #include "data/data-out.h"
  31 #include "data/format-guesser.h"
  32 #include "data/value-labels.h"
  33 #include "language/data-io/data-parser.h"
  34 #include "language/lexer/lexer.h"
  35 #include "libpspp/assertion.h"
  36 #include "libpspp/i18n.h"
  37 #include "libpspp/line-reader.h"
  38 #include "libpspp/message.h"
  39 #include "ui/gui/checkbox-treeview.h"
  40 #include "ui/gui/dialog-common.h"
  41 #include "ui/gui/executor.h"
  42 #include "ui/gui/helper.h"
  43 #include "ui/gui/builder-wrapper.h"
  44 #include "ui/gui/psppire-data-window.h"
  45 #include "ui/gui/psppire-dialog.h"
  46 #include "ui/gui/psppire-encoding-selector.h"
  47 #include "ui/gui/psppire-empty-list-store.h"
  48 #include "ui/gui/psppire-var-sheet.h"
  49 #include "ui/gui/psppire-var-store.h"
  50 #include "ui/gui/psppire-scanf.h"
  51 #include "ui/syntax-gen.h"
  52
  53 #include "gl/error.h"
  54 #include "gl/intprops.h"
  55 #include "gl/xalloc.h"
  56
  57 #include "gettext.h"
  58 #define _(msgid) gettext (msgid)
  59 #define N_(msgid) msgid
  60
  61 /* Page where the user chooses field separators. */
  62 struct separators_page
  63   {
  64     /* How to break lines into columns. */
  65     struct string separators;   /* Field separators. */
  66     struct string quotes;       /* Quote characters. */
  67     bool escape;                /* Doubled quotes yield a quote mark? */
  68
  69     GtkWidget *page;
  70     GtkWidget *custom_cb;
  71     GtkWidget *custom_entry;
  72     GtkWidget *quote_cb;
  73     GtkWidget *quote_combo;
  74     GtkEntry *quote_entry;
  75     GtkWidget *escape_cb;
  76     GtkTreeView *fields_tree_view;
  77   };
  78
  79 /* The "separators" page of the assistant. */
  80
  81 static void revise_fields_preview (struct import_assistant *ia);
  82 static void choose_likely_separators (struct import_assistant *ia);
  83 static void find_commonest_chars (unsigned long int histogram[UCHAR_MAX + 1],
  84                                   const char *targets, const char *def,
  85                                   struct string *result);
  86 static void clear_fields (struct import_assistant *ia);
  87 static void revise_fields_preview (struct import_assistant *);
  88 static void set_separators (struct import_assistant *);
  89 static void get_separators (struct import_assistant *);
  90 static void on_separators_custom_entry_notify (GObject *UNUSED,
  91                                                GParamSpec *UNUSED,
  92                                                struct import_assistant *);
  93 static void on_separators_custom_cb_toggle (GtkToggleButton *custom_cb,
  94                                             struct import_assistant *);
  95 static void on_quote_combo_change (GtkComboBox *combo,
  96                                    struct import_assistant *);
  97 static void on_quote_cb_toggle (GtkToggleButton *quote_cb,
  98                                 struct import_assistant *);
  99 static void on_separator_toggle (GtkToggleButton *, struct import_assistant *);
 100
 101 /* A common field separator and its identifying name. */
 102 struct separator
 103   {
 104     const char *name;           /* Name (for use with get_widget_assert). */
 105     int c;                      /* Separator character. */
 106   };
 107
 108 /* All the separators in the dialog box. */
 109 static const struct separator separators[] =
 110   {
 111     {"space", ' '},
 112     {"tab", '\t'},
 113     {"bang", '!'},
 114     {"colon", ':'},
 115     {"comma", ','},
 116     {"hyphen", '-'},
 117     {"pipe", '|'},
 118     {"semicolon", ';'},
 119     {"slash", '/'},
 120   };
 121 #define SEPARATOR_CNT (sizeof separators / sizeof *separators)
 122
 123 static void
 124 set_quote_list (GtkComboBoxEntry *cb)
 125 {
 126   GtkListStore *list =  gtk_list_store_new (1, G_TYPE_STRING);
 127   GtkTreeIter iter;
 128   gint i;
 129   const gchar *seperator[3] = {"'\"", "\'", "\""};
 130
 131   for (i = 0; i < 3; i++)
 132     {
 133       const gchar *s = seperator[i];
 134
 135       /* Add a new row to the model */
 136       gtk_list_store_append (list, &iter);
 137       gtk_list_store_set (list, &iter,
 138                           0, s,
 139                           -1);
 140
 141     }
 142
 143   gtk_combo_box_set_model (GTK_COMBO_BOX (cb), GTK_TREE_MODEL (list));
 144   g_object_unref (list);
 145
 146   gtk_combo_box_entry_set_text_column (cb, 0);
 147 }
 148
 149 /* Initializes IA's separators substructure. */
 150
 151 struct separators_page *
 152 separators_page_create (struct import_assistant *ia)
 153 {
 154   GtkBuilder *builder = ia->asst.builder;
 155
 156   size_t i;
 157
 158   struct separators_page *p = xzalloc (sizeof *p);
 159
 160   p->page = add_page_to_assistant (ia, get_widget_assert (builder, "Separators"),
 161                                    GTK_ASSISTANT_PAGE_CONTENT);
 162   p->custom_cb = get_widget_assert (builder, "custom-cb");
 163   p->custom_entry = get_widget_assert (builder, "custom-entry");
 164   p->quote_combo = get_widget_assert (builder, "quote-combo");
 165   p->quote_entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (p->quote_combo)));
 166   p->quote_cb = get_widget_assert (builder, "quote-cb");
 167   p->escape_cb = get_widget_assert (builder, "escape");
 168
 169   set_quote_list (GTK_COMBO_BOX_ENTRY (p->quote_combo));
 170   p->fields_tree_view = GTK_TREE_VIEW (get_widget_assert (builder, "fields"));
 171   g_signal_connect (p->quote_combo, "changed",
 172                     G_CALLBACK (on_quote_combo_change), ia);
 173   g_signal_connect (p->quote_cb, "toggled",
 174                     G_CALLBACK (on_quote_cb_toggle), ia);
 175   g_signal_connect (p->custom_entry, "notify::text",
 176                     G_CALLBACK (on_separators_custom_entry_notify), ia);
 177   g_signal_connect (p->custom_cb, "toggled",
 178                     G_CALLBACK (on_separators_custom_cb_toggle), ia);
 179   for (i = 0; i < SEPARATOR_CNT; i++)
 180     g_signal_connect (get_widget_assert (builder, separators[i].name),
 181                       "toggled", G_CALLBACK (on_separator_toggle), ia);
 182   g_signal_connect (p->escape_cb, "toggled",
 183                     G_CALLBACK (on_separator_toggle), ia);
 184
 185   return p;
 186 }
 187
 188 /* Frees IA's separators substructure. */
 189 void
 190 destroy_separators_page (struct import_assistant *ia)
 191 {
 192   struct separators_page *s = ia->separators;
 193
 194   ds_destroy (&s->separators);
 195   ds_destroy (&s->quotes);
 196   clear_fields (ia);
 197 }
 198
 199 /* Called just before the separators page becomes visible in the
 200    assistant. */
 201 void
 202 prepare_separators_page (struct import_assistant *ia)
 203 {
 204   revise_fields_preview (ia);
 205 }
 206
 207 /* Called when the Reset button is clicked on the separators
 208    page, resets the separators to the defaults. */
 209 void
 210 reset_separators_page (struct import_assistant *ia)
 211 {
 212   choose_likely_separators (ia);
 213   set_separators (ia);
 214 }
 215
 216 /* Frees and clears the column data in IA's separators
 217    substructure. */
 218 static void
 219 clear_fields (struct import_assistant *ia)
 220 {
 221   if (ia->column_cnt > 0)
 222     {
 223       struct column *col;
 224       size_t row;
 225
 226       for (row = 0; row < ia->file.line_cnt; row++)
 227         {
 228           const struct string *line = &ia->file.lines[row];
 229           const char *line_start = ds_data (line);
 230           const char *line_end = ds_end (line);
 231
 232           for (col = ia->columns; col < &ia->columns[ia->column_cnt]; col++)
 233             {
 234               char *s = ss_data (col->contents[row]);
 235               if (!(s >= line_start && s <= line_end))
 236                 ss_dealloc (&col->contents[row]);
 237             }
 238         }
 239
 240       for (col = ia->columns; col < &ia->columns[ia->column_cnt]; col++)
 241         {
 242           free (col->name);
 243           free (col->contents);
 244         }
 245
 246       free (ia->columns);
 247       ia->columns = NULL;
 248       ia->column_cnt = 0;
 249     }
 250 }
 251
 252 /* Breaks the file data in IA into columns based on the
 253    separators set in IA's separators substructure. */
 254 static void
 255 split_fields (struct import_assistant *ia)
 256 {
 257   struct separators_page *s = ia->separators;
 258   size_t columns_allocated;
 259   bool space_sep;
 260   size_t row;
 261
 262   clear_fields (ia);
 263
 264   /* Is space in the set of separators? */
 265   space_sep = ss_find_byte (ds_ss (&s->separators), ' ') != SIZE_MAX;
 266
 267   /* Split all the lines, not just those from
 268      ia->first_line.skip_lines on, so that we split the line that
 269      contains variables names if ia->first_line.variable_names is
 270      true. */
 271   columns_allocated = 0;
 272   for (row = 0; row < ia->file.line_cnt; row++)
 273     {
 274       struct string *line = &ia->file.lines[row];
 275       struct substring text = ds_ss (line);
 276       size_t column_idx;
 277
 278       for (column_idx = 0; ; column_idx++)
 279         {
 280           struct substring field;
 281           struct column *column;
 282
 283           if (space_sep)
 284             ss_ltrim (&text, ss_cstr (" "));
 285           if (ss_is_empty (text))
 286             {
 287               if (column_idx != 0)
 288                 break;
 289               field = text;
 290             }
 291           else if (!ds_is_empty (&s->quotes)
 292                    && ds_find_byte (&s->quotes, text.string[0]) != SIZE_MAX)
 293             {
 294               int quote = ss_get_byte (&text);
 295               if (!s->escape)
 296                 ss_get_until (&text, quote, &field);
 297               else
 298                 {
 299                   struct string s;
 300                   int c;
 301
 302                   ds_init_empty (&s);
 303                   while ((c = ss_get_byte (&text)) != EOF)
 304                     if (c != quote)
 305                       ds_put_byte (&s, c);
 306                     else if (ss_match_byte (&text, quote))
 307                       ds_put_byte (&s, quote);
 308                     else
 309                       break;
 310                   field = ds_ss (&s);
 311                 }
 312             }
 313           else
 314             ss_get_bytes (&text, ss_cspan (text, ds_ss (&s->separators)),
 315                           &field);
 316
 317           if (column_idx >= ia->column_cnt)
 318             {
 319               struct column *column;
 320
 321               if (ia->column_cnt >= columns_allocated)
 322                 ia->columns = x2nrealloc (ia->columns, &columns_allocated,
 323                                          sizeof *ia->columns);
 324               column = &ia->columns[ia->column_cnt++];
 325               column->name = NULL;
 326               column->width = 0;
 327               column->contents = xcalloc (ia->file.line_cnt,
 328                                           sizeof *column->contents);
 329             }
 330           column = &ia->columns[column_idx];
 331           column->contents[row] = field;
 332           if (ss_length (field) > column->width)
 333             column->width = ss_length (field);
 334
 335           if (space_sep)
 336             ss_ltrim (&text, ss_cstr (" "));
 337           if (ss_is_empty (text))
 338             break;
 339           if (ss_find_byte (ds_ss (&s->separators), ss_first (text))
 340               != SIZE_MAX)
 341             ss_advance (&text, 1);
 342         }
 343     }
 344 }
 345
 346 /* Chooses a name for each column on the separators page */
 347 static void
 348 choose_column_names (struct import_assistant *ia)
 349 {
 350   struct dictionary *dict;
 351   unsigned long int generated_name_count = 0;
 352   struct column *col;
 353   size_t name_row;
 354
 355   dict = dict_create (get_default_encoding ());
 356   name_row = ia->variable_names && ia->skip_lines ? ia->skip_lines : 0;
 357   for (col = ia->columns; col < &ia->columns[ia->column_cnt]; col++)
 358     {
 359       char *hint, *name;
 360
 361       hint = name_row ? ss_xstrdup (col->contents[name_row - 1]) : NULL;
 362       name = dict_make_unique_var_name (dict, hint, &generated_name_count);
 363       free (hint);
 364
 365       col->name = name;
 366       dict_create_var_assert (dict, name, 0);
 367     }
 368   dict_destroy (dict);
 369 }
 370
 371 /* Picks the most likely separator and quote characters based on
 372    IA's file data. */
 373 static void
 374 choose_likely_separators (struct import_assistant *ia)
 375 {
 376   unsigned long int histogram[UCHAR_MAX + 1] = { 0 };
 377   size_t row;
 378
 379   /* Construct a histogram of all the characters used in the
 380      file. */
 381   for (row = 0; row < ia->file.line_cnt; row++)
 382     {
 383       struct substring line = ds_ss (&ia->file.lines[row]);
 384       size_t length = ss_length (line);
 385       size_t i;
 386       for (i = 0; i < length; i++)
 387         histogram[(unsigned char) line.string[i]]++;
 388     }
 389
 390   find_commonest_chars (histogram, "\"'", "", &ia->separators->quotes);
 391   find_commonest_chars (histogram, ",;:/|!\t-", ",", &ia->separators->separators);
 392   ia->separators->escape = true;
 393 }
 394
 395 /* Chooses the most common character among those in TARGETS,
 396    based on the frequency data in HISTOGRAM, and stores it in
 397    RESULT.  If there is a tie for the most common character among
 398    those in TARGETS, the earliest character is chosen.  If none
 399    of the TARGETS appear at all, then DEF is used as a
 400    fallback. */
 401 static void
 402 find_commonest_chars (unsigned long int histogram[UCHAR_MAX + 1],
 403                       const char *targets, const char *def,
 404                       struct string *result)
 405 {
 406   unsigned char max = 0;
 407   unsigned long int max_count = 0;
 408
 409   for (; *targets != '\0'; targets++)
 410     {
 411       unsigned char c = *targets;
 412       unsigned long int count = histogram[c];
 413       if (count > max_count)
 414         {
 415           max = c;
 416           max_count = count;
 417         }
 418     }
 419   if (max_count > 0)
 420     {
 421       ds_clear (result);
 422       ds_put_byte (result, max);
 423     }
 424   else
 425     ds_assign_cstr (result, def);
 426 }
 427
 428 /* Revises the contents of the fields tree view based on the
 429    currently chosen set of separators. */
 430 static void
 431 revise_fields_preview (struct import_assistant *ia)
 432 {
 433   GtkWidget *w;
 434
 435   push_watch_cursor (ia);
 436
 437   w = GTK_WIDGET (ia->separators->fields_tree_view);
 438   gtk_widget_destroy (w);
 439   get_separators (ia);
 440   split_fields (ia);
 441   choose_column_names (ia);
 442   ia->separators->fields_tree_view = create_data_tree_view (
 443     true,
 444     GTK_CONTAINER (get_widget_assert (ia->asst.builder, "fields-scroller")),
 445     ia);
 446
 447   pop_watch_cursor (ia);
 448 }
 449
 450 /* Sets the widgets to match IA's separators substructure. */
 451 static void
 452 set_separators (struct import_assistant *ia)
 453 {
 454   struct separators_page *s = ia->separators;
 455   unsigned int seps;
 456   struct string custom;
 457   bool any_custom;
 458   bool any_quotes;
 459   size_t i;
 460
 461   ds_init_empty (&custom);
 462   seps = 0;
 463   for (i = 0; i < ds_length (&s->separators); i++)
 464     {
 465       unsigned char c = ds_at (&s->separators, i);
 466       int j;
 467
 468       for (j = 0; j < SEPARATOR_CNT; j++)
 469         {
 470           const struct separator *s = &separators[j];
 471           if (s->c == c)
 472             {
 473               seps += 1u << j;
 474               goto next;
 475             }
 476         }
 477
 478       ds_put_byte (&custom, c);
 479     next:;
 480     }
 481
 482   for (i = 0; i < SEPARATOR_CNT; i++)
 483     {
 484       const struct separator *s = &separators[i];
 485       GtkWidget *button = get_widget_assert (ia->asst.builder, s->name);
 486       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
 487                                     (seps & (1u << i)) != 0);
 488     }
 489   any_custom = !ds_is_empty (&custom);
 490   gtk_entry_set_text (GTK_ENTRY (s->custom_entry), ds_cstr (&custom));
 491   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (s->custom_cb),
 492                                 any_custom);
 493   gtk_widget_set_sensitive (s->custom_entry, any_custom);
 494   ds_destroy (&custom);
 495
 496   any_quotes = !ds_is_empty (&s->quotes);
 497
 498   gtk_entry_set_text (s->quote_entry,
 499                       any_quotes ? ds_cstr (&s->quotes) : "\"");
 500   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (s->quote_cb),
 501                                 any_quotes);
 502   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (s->escape_cb),
 503                                 s->escape);
 504   gtk_widget_set_sensitive (s->quote_combo, any_quotes);
 505   gtk_widget_set_sensitive (s->escape_cb, any_quotes);
 506 }
 507
 508 /* Sets IA's separators substructure to match the widgets. */
 509 static void
 510 get_separators (struct import_assistant *ia)
 511 {
 512   struct separators_page *s = ia->separators;
 513   int i;
 514
 515   ds_clear (&s->separators);
 516   for (i = 0; i < SEPARATOR_CNT; i++)
 517     {
 518       const struct separator *sep = &separators[i];
 519       GtkWidget *button = get_widget_assert (ia->asst.builder, sep->name);
 520       if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
 521         ds_put_byte (&s->separators, sep->c);
 522     }
 523
 524   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (s->custom_cb)))
 525     ds_put_cstr (&s->separators,
 526                  gtk_entry_get_text (GTK_ENTRY (s->custom_entry)));
 527
 528   if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (s->quote_cb)))
 529     {
 530       gchar *text = gtk_combo_box_get_active_text (
 531                       GTK_COMBO_BOX (s->quote_combo));
 532       ds_assign_cstr (&s->quotes, text);
 533       g_free (text);
 534     }
 535   else
 536     ds_clear (&s->quotes);
 537   s->escape = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (s->escape_cb));
 538 }
 539
 540 /* Called when the user changes the entry field for custom
 541    separators. */
 542 static void
 543 on_separators_custom_entry_notify (GObject *gobject UNUSED,
 544                                    GParamSpec *arg1 UNUSED,
 545                                    struct import_assistant *ia)
 546 {
 547   revise_fields_preview (ia);
 548 }
 549
 550 /* Called when the user toggles the checkbox that enables custom
 551    separators. */
 552 static void
 553 on_separators_custom_cb_toggle (GtkToggleButton *custom_cb,
 554                                 struct import_assistant *ia)
 555 {
 556   bool is_active = gtk_toggle_button_get_active (custom_cb);
 557   gtk_widget_set_sensitive (ia->separators->custom_entry, is_active);
 558   revise_fields_preview (ia);
 559 }
 560
 561 /* Called when the user changes the selection in the combo box
 562    that selects a quote character. */
 563 static void
 564 on_quote_combo_change (GtkComboBox *combo, struct import_assistant *ia)
 565 {
 566   revise_fields_preview (ia);
 567 }
 568
 569 /* Called when the user toggles the checkbox that enables
 570    quoting. */
 571 static void
 572 on_quote_cb_toggle (GtkToggleButton *quote_cb, struct import_assistant *ia)
 573 {
 574   bool is_active = gtk_toggle_button_get_active (quote_cb);
 575   gtk_widget_set_sensitive (ia->separators->quote_combo, is_active);
 576   gtk_widget_set_sensitive (ia->separators->escape_cb, is_active);
 577   revise_fields_preview (ia);
 578 }
 579
 580 /* Called when the user toggles one of the separators
 581    checkboxes. */
 582 static void
 583 on_separator_toggle (GtkToggleButton *toggle UNUSED,
 584                      struct import_assistant *ia)
 585 {
 586   revise_fields_preview (ia);
 587 }
 588