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