pintos-os.org Git - pspp/blob - src/ui/gui/psppire-delimited-text.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2017 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 #include <gettext.h>
  19 #define _(msgid) gettext (msgid)
  20 #define P_(msgid) msgid
  21
  22 #include "psppire-delimited-text.h"
  23 #include "psppire-text-file.h"
  24 #include "libpspp/str.h"
  25 #include "libpspp/i18n.h"
  26
  27 #include <gtk/gtk.h>
  28
  29 /* Properties */
  30 enum
  31   {
  32     PROP_0,
  33     PROP_CHILD,
  34     PROP_DELIMITERS,
  35     PROP_FIRST_LINE
  36   };
  37
  38 static void
  39 count_delims (PsppireDelimitedText *tf)
  40 {
  41   if (tf->child)
  42     {
  43       tf->max_delimiters = 0;
  44       GtkTreeIter iter;
  45       gboolean valid;
  46       for (valid = gtk_tree_model_get_iter_first (tf->child, &iter);
  47            valid;
  48            valid = gtk_tree_model_iter_next (tf->child, &iter))
  49         {
  50           // FIXME: Box these lines to avoid constant allocation/deallocation
  51           gchar *foo = 0;
  52           gtk_tree_model_get (tf->child, &iter, 1, &foo, -1);
  53           {
  54             char *line = foo;
  55             gint count = 0;
  56             while (*line)
  57               {
  58                 GSList *del;
  59                 for (del = tf->delimiters; del; del = g_slist_next (del))
  60                   {
  61                     if (*line == GPOINTER_TO_INT (del->data))
  62                       count++;
  63                   }
  64                 line++;
  65               }
  66             tf->max_delimiters = MAX (tf->max_delimiters, count);
  67           }
  68           g_free (foo);
  69         }
  70     }
  71   //  g_print ("Max Number of delimiters per row: %d\n", tf->max_delimiters);
  72 }
  73
  74 static void
  75 cache_invalidate (PsppireDelimitedText *tf)
  76 {
  77   memset (tf->cache_starts, 0, 512);
  78   if (tf->const_cache.string)
  79     {
  80       ss_dealloc (&tf->const_cache);
  81       tf->const_cache.string = NULL;
  82       tf->cache_row = -1;
  83     }
  84 }
  85
  86 static void
  87 psppire_delimited_text_set_property (GObject         *object,
  88                                 guint            prop_id,
  89                                 const GValue    *value,
  90                                 GParamSpec      *pspec)
  91 {
  92   PsppireDelimitedText *tf = PSPPIRE_DELIMITED_TEXT (object);
  93
  94   switch (prop_id)
  95     {
  96     case PROP_FIRST_LINE:
  97       tf->first_line = g_value_get_int (value);
  98       break;
  99     case PROP_CHILD:
 100       tf->child = g_value_get_object (value);
 101       break;
 102     case PROP_DELIMITERS:
 103       g_slist_free (tf->delimiters);
 104       tf->delimiters =  g_slist_copy (g_value_get_pointer (value));
 105       break;
 106     default:
 107       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 108       break;
 109     };
 110
 111   cache_invalidate (tf);
 112   count_delims (tf);
 113 }
 114
 115 static void
 116 psppire_delimited_text_get_property (GObject         *object,
 117                                 guint            prop_id,
 118                                 GValue          *value,
 119                                 GParamSpec      *pspec)
 120 {
 121   PsppireDelimitedText *text_file = PSPPIRE_DELIMITED_TEXT (object);
 122
 123   switch (prop_id)
 124     {
 125     case PROP_FIRST_LINE:
 126       g_value_set_int (value, text_file->first_line);
 127       break;
 128     case PROP_DELIMITERS:
 129       g_value_set_pointer (value, text_file->delimiters);
 130       break;
 131     default:
 132       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 133       break;
 134     };
 135 }
 136
 137
 138 static void psppire_delimited_text_init            (PsppireDelimitedText      *text_file);
 139 static void psppire_delimited_text_class_init      (PsppireDelimitedTextClass *class);
 140
 141 static void psppire_delimited_text_finalize        (GObject           *object);
 142 static void psppire_delimited_text_dispose        (GObject           *object);
 143
 144 static GObjectClass *parent_class = NULL;
 145
 146
 147 static gboolean
 148 __tree_get_iter (GtkTreeModel *tree_model,
 149                  GtkTreeIter *iter,
 150                  GtkTreePath *path)
 151 {
 152   PsppireDelimitedText *file = PSPPIRE_DELIMITED_TEXT (tree_model);
 153   if (path == NULL)
 154     return FALSE;
 155
 156   //  g_print ("%s:%d %s %s\n", __FILE__, __LINE__, __FUNCTION__, gtk_tree_path_to_string (path));
 157
 158   gint *indices = gtk_tree_path_get_indices (path);
 159
 160   if (!indices)
 161     return FALSE;
 162
 163   gint n = *indices;
 164
 165   gint children = gtk_tree_model_iter_n_children (file->child, NULL);
 166
 167   if (n >= children - file->first_line)
 168     return FALSE;
 169
 170   //  g_print ("%s:%d %s  %d Children: %d\n", __FILE__, __LINE__, __FUNCTION__, n, children);
 171
 172   iter->user_data = GINT_TO_POINTER (n);
 173   iter->stamp = file->stamp;
 174
 175   return TRUE;
 176 }
 177
 178
 179 static gboolean
 180 __tree_iter_next (GtkTreeModel *tree_model,
 181                   GtkTreeIter *iter)
 182 {
 183   PsppireDelimitedText *file  = PSPPIRE_DELIMITED_TEXT (tree_model);
 184   g_return_val_if_fail (file->stamp == iter->stamp, FALSE);
 185
 186   gint n = GPOINTER_TO_INT (iter->user_data);
 187
 188   //  g_print ("%s:%d %s %d\n", __FILE__, __LINE__, __FUNCTION__, n);
 189
 190   gint children = gtk_tree_model_iter_n_children (file->child, NULL);
 191
 192   if (n + 1 >= children - file->first_line)
 193     return FALSE;
 194
 195   iter->user_data = GINT_TO_POINTER (n + 1);
 196
 197   return TRUE;
 198 }
 199
 200
 201 static GType
 202 __tree_get_column_type (GtkTreeModel *tree_model,
 203                         gint          index)
 204 {
 205   //  g_print ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
 206   if (index == 0)
 207     return G_TYPE_INT;
 208
 209   return G_TYPE_STRING;
 210 }
 211
 212 static gboolean
 213 __iter_has_child (GtkTreeModel *tree_model,
 214                   GtkTreeIter  *iter)
 215 {
 216   g_print ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
 217   return 0;
 218 }
 219
 220
 221 static gboolean
 222 __iter_parent     (GtkTreeModel *tree_model,
 223                    GtkTreeIter  *iter,
 224                    GtkTreeIter  *child)
 225 {
 226   g_print ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
 227   return 0;
 228 }
 229
 230 static GtkTreePath *
 231 __tree_get_path (GtkTreeModel *tree_model,
 232                  GtkTreeIter  *iter)
 233 {
 234   //  g_print ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
 235   PsppireDelimitedText *file  = PSPPIRE_DELIMITED_TEXT (tree_model);
 236   g_return_val_if_fail (file->stamp == iter->stamp, FALSE);
 237
 238   gint n = GPOINTER_TO_INT (iter->user_data);
 239
 240   gint children = gtk_tree_model_iter_n_children (file->child, NULL);
 241
 242   if (n >= children - file->first_line)
 243     return NULL;
 244
 245   return gtk_tree_path_new_from_indices (n, -1);
 246 }
 247
 248
 249 static gboolean
 250 __iter_children (GtkTreeModel *tree_model,
 251                               GtkTreeIter *iter,
 252                               GtkTreeIter *parent)
 253 {
 254   g_print ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
 255   return 0;
 256 }
 257
 258
 259 static gint
 260 __tree_model_iter_n_children (GtkTreeModel *tree_model,
 261                               GtkTreeIter *iter)
 262 {
 263   g_print ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
 264   g_assert (iter == NULL);
 265   return 0;
 266 }
 267
 268 static GtkTreeModelFlags
 269 __tree_model_get_flags (GtkTreeModel *model)
 270 {
 271   //  g_print ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
 272   g_return_val_if_fail (PSPPIRE_IS_DELIMITED_TEXT (model), (GtkTreeModelFlags) 0);
 273
 274   return GTK_TREE_MODEL_LIST_ONLY;
 275 }
 276
 277 static gint
 278 __tree_model_get_n_columns (GtkTreeModel *tree_model)
 279 {
 280   //  g_print ("%s:%d %s\n", __FILE__, __LINE__, __FUNCTION__);
 281   PsppireDelimitedText *tf  = PSPPIRE_DELIMITED_TEXT (tree_model);
 282
 283   /* + 1 for the trailing field and +1 for the leading line number column */
 284   return tf->max_delimiters + 1 + 1;
 285 }
 286
 287
 288 static gboolean
 289 __iter_nth_child (GtkTreeModel *tree_model,
 290                   GtkTreeIter *iter,
 291                   GtkTreeIter *parent,
 292                   gint n)
 293 {
 294   //  g_print ("%s:%d %s %d\n", __FILE__, __LINE__, __FUNCTION__, n);
 295   PsppireDelimitedText *file  = PSPPIRE_DELIMITED_TEXT (tree_model);
 296
 297   g_assert (parent == NULL);
 298
 299   g_return_val_if_fail (file, FALSE);
 300
 301   gint children = gtk_tree_model_iter_n_children (file->child, NULL);
 302
 303   if (n >= children - file->first_line)
 304     {
 305       iter->stamp = -1;
 306       iter->user_data = NULL;
 307       return FALSE;
 308     }
 309
 310   iter->user_data = GINT_TO_POINTER (n);
 311   iter->stamp = file->stamp;
 312
 313   return TRUE;
 314 }
 315
 316
 317 /* Split row N into it's delimited fields (if it is not already cached)
 318    and set this row as the current cache. */
 319 static void
 320 split_row_into_fields (PsppireDelimitedText *file, gint n)
 321 {
 322   if (n == file->cache_row)  /* Cache hit */
 323     {
 324       return;
 325     }
 326
 327   memset (file->cache_starts, 0, 512);
 328   /* Cache miss */
 329   if (file->const_cache.string)
 330     {
 331       ss_dealloc (&file->const_cache);
 332     }
 333   ss_alloc_substring_pool (&file->const_cache,
 334                            PSPPIRE_TEXT_FILE (file->child)->lines[n], NULL);
 335   struct substring cs = file->const_cache;
 336   int field = 0;
 337   file->cache_starts[0] = cs.string;
 338   for (;
 339        UINT32_MAX != ss_first_mb (cs);
 340        ss_get_mb (&cs))
 341     {
 342       ucs4_t xx = ss_first_mb (cs);
 343       GSList *del;
 344       for (del = file->delimiters; del; del = g_slist_next (del))
 345         {
 346           if (xx == GPOINTER_TO_INT (del->data))
 347             {
 348               field++;
 349               int char_len = ss_first_mblen (cs);
 350               file->cache_starts[field] = cs.string + char_len;
 351               while (char_len > 0)
 352                 {
 353                   cs.string[char_len - 1] = '\0';
 354                   char_len--;
 355                 }
 356               break;
 357             }
 358         }
 359     }
 360
 361   file->cache_row = n;
 362 }
 363
 364 const gchar *
 365 psppire_delimited_text_get_header_title (PsppireDelimitedText *file, gint column)
 366 {
 367   if (file->first_line <= 0)
 368     return NULL;
 369
 370   split_row_into_fields (file, file->first_line - 1);
 371
 372   return file->cache_starts [column];
 373 }
 374
 375 static void
 376 __get_value (GtkTreeModel *tree_model,
 377              GtkTreeIter *iter,
 378              gint column,
 379              GValue *value)
 380 {
 381   //  g_print ("%s:%d %s Col: %d\n", __FILE__, __LINE__, __FUNCTION__, column);
 382   PsppireDelimitedText *file  = PSPPIRE_DELIMITED_TEXT (tree_model);
 383
 384   g_return_if_fail (iter->stamp == file->stamp);
 385
 386   gint n = GPOINTER_TO_INT (iter->user_data) + file->first_line;
 387
 388   //  g_print ("%s:%d Row: %d\n", __FILE__, __LINE__, n);
 389
 390   if (column == 0)
 391     {
 392       g_value_init (value, G_TYPE_INT);
 393       g_value_set_int (value, n + 1);
 394       return;
 395     }
 396
 397   g_value_init (value, G_TYPE_STRING);
 398
 399   split_row_into_fields (file, n);
 400
 401   g_value_set_string (value, file->cache_starts [column - 1]);
 402 }
 403
 404
 405 static void
 406 __tree_model_init (GtkTreeModelIface *iface)
 407 {
 408   iface->get_flags       = __tree_model_get_flags;
 409   iface->get_n_columns   = __tree_model_get_n_columns ;
 410   iface->get_column_type = __tree_get_column_type;
 411   iface->get_iter        = __tree_get_iter;
 412   iface->iter_next       = __tree_iter_next;
 413   iface->get_path        = __tree_get_path;
 414   iface->get_value       = __get_value;
 415
 416   iface->iter_children   = __iter_children;
 417   iface->iter_has_child  = __iter_has_child;
 418   iface->iter_n_children = __tree_model_iter_n_children;
 419   iface->iter_nth_child  = __iter_nth_child;
 420   iface->iter_parent     = __iter_parent;
 421 }
 422
 423
 424 GType
 425 psppire_delimited_text_get_type (void)
 426 {
 427   static GType text_file_type = 0;
 428
 429   if (!text_file_type)
 430     {
 431       static const GTypeInfo text_file_info =
 432         {
 433           sizeof (PsppireDelimitedTextClass),
 434           NULL,         /* base_init */
 435           NULL,         /* base_finalize */
 436           (GClassInitFunc) psppire_delimited_text_class_init,
 437           NULL,         /* class_finalize */
 438           NULL,         /* class_data */
 439           sizeof (PsppireDelimitedText),
 440           0,
 441           (GInstanceInitFunc) psppire_delimited_text_init,
 442         };
 443
 444       static const GInterfaceInfo tree_model_info = {
 445         (GInterfaceInitFunc) __tree_model_init,
 446         NULL,
 447         NULL
 448       };
 449
 450       text_file_type = g_type_register_static (G_TYPE_OBJECT,
 451                                                "PsppireDelimitedText",
 452                                                &text_file_info, 0);
 453
 454       g_type_add_interface_static (text_file_type, GTK_TYPE_TREE_MODEL,
 455                                    &tree_model_info);
 456     }
 457
 458   return text_file_type;
 459 }
 460
 461
 462 static void
 463 psppire_delimited_text_class_init (PsppireDelimitedTextClass *class)
 464 {
 465   GObjectClass *object_class;
 466
 467   parent_class = g_type_class_peek_parent (class);
 468   object_class = (GObjectClass*) class;
 469
 470   GParamSpec *first_line_spec =
 471     g_param_spec_int ("first-line",
 472                       "First Line",
 473                       P_("The first line to be considered."),
 474                       0, 1000, 0,
 475                       G_PARAM_READWRITE);
 476
 477   GParamSpec *delimiters_spec =
 478     g_param_spec_pointer ("delimiters",
 479                           "Field Delimiters",
 480                           P_("A GSList of gunichars which delimit the fields."),
 481                           G_PARAM_READWRITE);
 482
 483   GParamSpec *child_spec =
 484     g_param_spec_object ("child",
 485                          "Child Model",
 486                          P_("The GtkTextModel which this object wraps."),
 487                          GTK_TYPE_TREE_MODEL,
 488                          G_PARAM_CONSTRUCT_ONLY |G_PARAM_READWRITE);
 489
 490   object_class->set_property = psppire_delimited_text_set_property;
 491   object_class->get_property = psppire_delimited_text_get_property;
 492
 493   g_object_class_install_property (object_class,
 494                                    PROP_CHILD,
 495                                    child_spec);
 496
 497   g_object_class_install_property (object_class,
 498                                    PROP_DELIMITERS,
 499                                    delimiters_spec);
 500
 501   g_object_class_install_property (object_class,
 502                                    PROP_FIRST_LINE,
 503                                    first_line_spec);
 504
 505   object_class->finalize = psppire_delimited_text_finalize;
 506   object_class->dispose = psppire_delimited_text_dispose;
 507 }
 508
 509
 510 static void
 511 psppire_delimited_text_init (PsppireDelimitedText *text_file)
 512 {
 513   text_file->child = NULL;
 514   text_file->first_line = 0;
 515   text_file->delimiters = g_slist_prepend (NULL, GINT_TO_POINTER (':'));
 516
 517   text_file->const_cache.string = NULL;
 518   text_file->const_cache.length = 0;
 519   text_file->cache_row = -1;
 520   memset (text_file->cache_starts, 0, 512);
 521
 522   text_file->max_delimiters = 0;
 523
 524   text_file->dispose_has_run = FALSE;
 525   text_file->stamp = g_random_int ();
 526 }
 527
 528
 529 GtkTreeModel *
 530 psppire_delimited_text_new (GtkTreeModel *child)
 531 {
 532   PsppireDelimitedText *retval =
 533     g_object_new (PSPPIRE_TYPE_DELIMITED_TEXT,
 534                   "child", child,
 535                   NULL);
 536
 537   return retval;
 538 }
 539
 540 static void
 541 psppire_delimited_text_finalize (GObject *object)
 542 {
 543   PsppireDelimitedText *tf = PSPPIRE_DELIMITED_TEXT (object);
 544
 545   g_slist_free (tf->delimiters);
 546
 547   ss_dealloc (&tf->const_cache);
 548
 549   /* must chain up */
 550   (* parent_class->finalize) (object);
 551 }
 552
 553
 554 static void
 555 psppire_delimited_text_dispose (GObject *object)
 556 {
 557   PsppireDelimitedText *ds = PSPPIRE_DELIMITED_TEXT (object);
 558
 559   if (ds->dispose_has_run)
 560     return;
 561
 562   /* must chain up */
 563   (* parent_class->dispose) (object);
 564
 565   ds->dispose_has_run = TRUE;
 566 }