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