src/ui/gui/psppire-dict.c

   1 /*
   2     PSPPIRE --- A Graphical User Interface for PSPP
   3     Copyright (C) 2004, 2006  Free Software Foundation
   4     Written by John Darrington
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19     02110-1301, USA. */
  20
  21
  22 #include <string.h>
  23 #include <stdlib.h>
  24
  25 #include <gtk/gtk.h>
  26 #include <gtksheet/gtkextra-marshal.h>
  27
  28 #include "psppire-object.h"
  29 #include "psppire-dict.h"
  30 #include <data/format.h>
  31 #include <data/dictionary.h>
  32 #include <data/missing-values.h>
  33 #include <data/value-labels.h>
  34 #include <data/variable.h>
  35
  36 #include "message-dialog.h"
  37
  38 /* --- prototypes --- */
  39 static void psppire_dict_class_init     (PsppireDictClass       *class);
  40 static void psppire_dict_init   (PsppireDict            *dict);
  41 static void psppire_dict_finalize       (GObject                *object);
  42
  43 static void dictionary_tree_model_init(GtkTreeModelIface *iface);
  44
  45
  46 /* --- variables --- */
  47 static GObjectClass     *parent_class = NULL;
  48
  49 enum  {VARIABLE_CHANGED,
  50        VARIABLE_RESIZED,
  51        VARIABLE_INSERTED,
  52        VARIABLES_DELETED,
  53        n_SIGNALS};
  54
  55 static guint signal[n_SIGNALS];
  56
  57 #define CACHE_CHUNK 5
  58
  59 /* --- functions --- */
  60 /**
  61  * psppire_dict_get_type:
  62  * @returns: the type ID for accelerator groups.
  63  */
  64 GType
  65 psppire_dict_get_type (void)
  66 {
  67   static GType object_type = 0;
  68
  69   if (!object_type)
  70     {
  71       static const GTypeInfo object_info = {
  72         sizeof (PsppireDictClass),
  73         (GBaseInitFunc) NULL,
  74         (GBaseFinalizeFunc) NULL,
  75         (GClassInitFunc) psppire_dict_class_init,
  76         NULL,   /* class_finalize */
  77         NULL,   /* class_data */
  78         sizeof (PsppireDict),
  79         0,      /* n_preallocs */
  80         (GInstanceInitFunc) psppire_dict_init,
  81       };
  82
  83       static const GInterfaceInfo tree_model_info = {
  84         (GInterfaceInitFunc) dictionary_tree_model_init,
  85         NULL,
  86         NULL
  87       };
  88
  89       object_type = g_type_register_static (G_TYPE_PSPPIRE_OBJECT,
  90                                             "PsppireDict",
  91                                             &object_info, 0);
  92
  93       g_type_add_interface_static(object_type, GTK_TYPE_TREE_MODEL,
  94                                   &tree_model_info);
  95
  96
  97     }
  98
  99   return object_type;
 100 }
 101
 102
 103 static void
 104 psppire_dict_class_init (PsppireDictClass *class)
 105 {
 106   GObjectClass *object_class = G_OBJECT_CLASS (class);
 107
 108   parent_class = g_type_class_peek_parent (class);
 109
 110   object_class->finalize = psppire_dict_finalize;
 111
 112   signal[VARIABLE_CHANGED] =
 113     g_signal_new ("variable_changed",
 114                   G_TYPE_FROM_CLASS(class),
 115                   G_SIGNAL_RUN_FIRST,
 116                   0,
 117                   NULL, NULL,
 118                   g_cclosure_marshal_VOID__INT,
 119                   G_TYPE_NONE,
 120                   1,
 121                   G_TYPE_INT);
 122
 123
 124
 125   signal[VARIABLE_INSERTED] =
 126     g_signal_new ("variable_inserted",
 127                   G_TYPE_FROM_CLASS(class),
 128                   G_SIGNAL_RUN_FIRST,
 129                   0,
 130                   NULL, NULL,
 131                   g_cclosure_marshal_VOID__INT,
 132                   G_TYPE_NONE,
 133                   1,
 134                   G_TYPE_INT);
 135
 136
 137   signal[VARIABLES_DELETED] =
 138     g_signal_new ("variables_deleted",
 139                   G_TYPE_FROM_CLASS(class),
 140                   G_SIGNAL_RUN_FIRST,
 141                   0,
 142                   NULL, NULL,
 143                   gtkextra_VOID__INT_INT,
 144                   G_TYPE_NONE,
 145                   2,
 146                   G_TYPE_INT,
 147                   G_TYPE_INT);
 148
 149
 150   signal[VARIABLE_RESIZED] =
 151     g_signal_new ("dict-size-changed",
 152                   G_TYPE_FROM_CLASS(class),
 153                   G_SIGNAL_RUN_FIRST,
 154                   0,
 155                   NULL, NULL,
 156                   gtkextra_VOID__INT_INT,
 157                   G_TYPE_NONE,
 158                   2,
 159                   G_TYPE_INT,
 160                   G_TYPE_INT);
 161
 162 }
 163
 164 static void
 165 psppire_dict_finalize (GObject *object)
 166 {
 167   PsppireDict *d = PSPPIRE_DICT (object);
 168
 169   dict_destroy(d->dict);
 170
 171   G_OBJECT_CLASS (parent_class)->finalize (object);
 172 }
 173
 174 /* Pass on callbacks from src/data/dictionary, as
 175    signals in the Gtk library */
 176 static void
 177 addcb (struct dictionary *d, int idx, void *pd)
 178 {
 179   g_signal_emit(pd, signal[VARIABLE_INSERTED], 0, idx);
 180 }
 181
 182 static void
 183 delcb (struct dictionary *d, int idx, void *pd)
 184 {
 185   g_signal_emit(pd, signal[VARIABLES_DELETED], 0, idx, 1);
 186 }
 187
 188 static void
 189 mutcb (struct dictionary *d, int idx, void *pd)
 190 {
 191   g_signal_emit(pd, signal[VARIABLE_CHANGED], 0, idx);
 192 }
 193
 194 static const struct dict_callbacks gui_callbacks =
 195   {
 196     addcb,
 197     delcb,
 198     mutcb
 199   };
 200
 201 static void
 202 psppire_dict_init (PsppireDict *psppire_dict)
 203 {
 204   psppire_dict->dict = dict_create ();
 205
 206   dict_set_callbacks (psppire_dict->dict, &gui_callbacks, psppire_dict);
 207
 208   psppire_dict->stamp = g_random_int();
 209 }
 210
 211 /**
 212  * psppire_dict_new:
 213  * @returns: a new #PsppireDict object
 214  *
 215  * Creates a new #PsppireDict.
 216  */
 217 PsppireDict*
 218 psppire_dict_new (void)
 219 {
 220   return g_object_new (G_TYPE_PSPPIRE_DICT, NULL);
 221 }
 222
 223
 224 /**
 225  * psppire_dict_new_from_dict:
 226  * @returns: a new #PsppireDict object
 227  *
 228  * Creates a new #PsppireDict.
 229  */
 230 PsppireDict*
 231 psppire_dict_new_from_dict (struct dictionary *d)
 232 {
 233   PsppireDict *new_dict = g_object_new (G_TYPE_PSPPIRE_DICT, NULL);
 234   new_dict->dict = d;
 235
 236   return new_dict;
 237 }
 238
 239
 240 /* Returns a valid name for a new variable in DICT.
 241    The return value is statically allocated */
 242 static gchar *
 243 auto_generate_var_name (PsppireDict *dict)
 244 {
 245   gint d = 0;
 246   static gchar name[10];
 247
 248   while (g_snprintf(name, 10, "VAR%05d",d++),
 249          psppire_dict_lookup_var(dict, name))
 250     ;
 251
 252   return name;
 253 }
 254
 255 /* Insert a new variable at posn IDX, with the name NAME.
 256    If NAME is null, then a name will be automatically assigned.
 257  */
 258 void
 259 psppire_dict_insert_variable(PsppireDict *d, gint idx, const gchar *name)
 260 {
 261   struct variable *var ;
 262   g_return_if_fail(d);
 263   g_return_if_fail(G_IS_PSPPIRE_DICT(d));
 264
 265
 266   if ( ! name )
 267     name = auto_generate_var_name(d);
 268
 269   var = dict_create_var(d->dict, name, 0);
 270
 271   dict_reorder_var(d->dict, var, idx);
 272
 273   g_signal_emit(d, signal[VARIABLE_INSERTED], 0, idx );
 274 }
 275
 276 /* Delete N variables beginning at FIRST */
 277 void
 278 psppire_dict_delete_variables(PsppireDict *d, gint first, gint n)
 279 {
 280   gint idx;
 281   g_return_if_fail(d);
 282   g_return_if_fail(d->dict);
 283   g_return_if_fail(G_IS_PSPPIRE_DICT(d));
 284
 285   for (idx = 0 ; idx < n ; ++idx )
 286     {
 287       struct variable *var;
 288
 289       /* Do nothing if it's out of bounds */
 290       if ( first >= dict_get_var_cnt (d->dict))
 291         break;
 292
 293       var = dict_get_var(d->dict, first);
 294       dict_delete_var (d->dict, var);
 295     }
 296   dict_compact_values(d->dict);
 297
 298   g_signal_emit(d, signal[VARIABLES_DELETED], 0, first, idx );
 299 }
 300
 301
 302 void
 303 psppire_dict_set_name(PsppireDict* d, gint idx, const gchar *name)
 304 {
 305   struct variable *var;
 306   g_assert(d);
 307   g_assert(G_IS_PSPPIRE_DICT(d));
 308
 309
 310   if ( idx < dict_get_var_cnt(d->dict))
 311     {
 312       /* This is an existing variable? */
 313       var = dict_get_var(d->dict, idx);
 314       dict_rename_var(d->dict, var, name);
 315       g_signal_emit(d, signal[VARIABLE_CHANGED], 0, idx);
 316     }
 317   else
 318     {
 319       /* new variable */
 320       dict_create_var(d->dict, name, 0);
 321       g_signal_emit(d, signal[VARIABLE_INSERTED], 0, idx);
 322     }
 323 }
 324
 325
 326
 327 /* Return the IDXth variable */
 328 struct variable *
 329 psppire_dict_get_variable(PsppireDict *d, gint idx)
 330 {
 331   g_return_val_if_fail(d, NULL);
 332   g_return_val_if_fail(d->dict, NULL);
 333
 334   if ( dict_get_var_cnt (d->dict) <= idx )
 335     return NULL;
 336
 337   return dict_get_var (d->dict, idx);
 338 }
 339
 340
 341 /* Return the number of variables in the dictionary */
 342 gint
 343 psppire_dict_get_var_cnt (const PsppireDict *d)
 344 {
 345   g_return_val_if_fail (d, -1);
 346   g_return_val_if_fail (d->dict, -1);
 347
 348   return dict_get_var_cnt (d->dict);
 349 }
 350
 351
 352 /* Return a variable by name.
 353    Return NULL if it doesn't exist
 354 */
 355 struct variable *
 356 psppire_dict_lookup_var (const PsppireDict *d, const gchar *name)
 357 {
 358   g_return_val_if_fail (d, NULL);
 359   g_return_val_if_fail (d->dict, NULL);
 360
 361   return dict_lookup_var (d->dict, name);
 362 }
 363
 364
 365 void
 366 psppire_dict_var_changed (PsppireDict *d, gint idx)
 367 {
 368   g_return_if_fail(d);
 369
 370   g_signal_emit(d, signal[VARIABLE_CHANGED], 0, idx);
 371 }
 372
 373
 374 /* Clears the contents of D */
 375 void
 376 psppire_dict_clear(PsppireDict *d)
 377 {
 378   g_return_if_fail(d);
 379   g_return_if_fail(d->dict);
 380
 381   {
 382     const gint n_vars = dict_get_var_cnt(d->dict);
 383
 384     dict_clear(d->dict);
 385
 386     g_signal_emit(d, signal[VARIABLES_DELETED], 0, 0, n_vars );
 387   }
 388 }
 389
 390
 391
 392 /* Return true is NAME would be a valid name of a variable to add to the
 393    dictionary.  False otherwise.
 394    If REPORT is true, then invalid names will be reported as such as errors
 395 */
 396 gboolean
 397 psppire_dict_check_name(const PsppireDict *dict,
 398                      const gchar *name, gboolean report)
 399 {
 400   if ( ! var_is_valid_name(name, report ) )
 401       return FALSE;
 402
 403   if (psppire_dict_lookup_var(dict, name))
 404     {
 405       if ( report )
 406         msg(ME,"Duplicate variable name.");
 407       return FALSE;
 408     }
 409
 410   return TRUE;
 411 }
 412
 413
 414 inline gint
 415 psppire_dict_get_next_value_idx (const PsppireDict *dict)
 416 {
 417   return dict_get_next_value_idx(dict->dict);
 418 }
 419
 420
 421 void
 422 psppire_dict_resize_variable (PsppireDict *d, const struct variable *pv,
 423                               gint old_size, gint new_size)
 424 {
 425   gint fv;
 426   g_return_if_fail (d);
 427   g_return_if_fail (d->dict);
 428
 429   if ( old_size == new_size )
 430     return ;
 431
 432   dict_compact_values (d->dict);
 433
 434   fv = var_get_case_index (pv);
 435
 436   g_signal_emit(d, signal[VARIABLE_RESIZED], 0,
 437                 fv + old_size,
 438                 new_size - old_size );
 439 }
 440
 441
 442 /* Tree Model Stuff */
 443
 444 static GtkTreeModelFlags tree_model_get_flags (GtkTreeModel *model);
 445
 446 static gint tree_model_n_columns (GtkTreeModel *model);
 447
 448 static GType tree_model_column_type (GtkTreeModel *model, gint index);
 449
 450 static gboolean tree_model_get_iter (GtkTreeModel *model, GtkTreeIter *iter,
 451                                      GtkTreePath *path);
 452
 453 static gboolean tree_model_iter_next (GtkTreeModel *model, GtkTreeIter *iter);
 454
 455 static GtkTreePath * tree_model_get_path (GtkTreeModel *model,
 456                                           GtkTreeIter *iter);
 457
 458 static void tree_model_get_value (GtkTreeModel *model, GtkTreeIter *iter,
 459                                   gint column, GValue *value);
 460
 461 static gboolean tree_model_nth_child (GtkTreeModel *model, GtkTreeIter *iter,
 462                                       GtkTreeIter *parent, gint n);
 463
 464
 465 static void
 466 dictionary_tree_model_init (GtkTreeModelIface *iface)
 467 {
 468   iface->get_flags = tree_model_get_flags;
 469   iface->get_n_columns = tree_model_n_columns;
 470   iface->get_column_type = tree_model_column_type;
 471   iface->get_iter = tree_model_get_iter;
 472   iface->iter_next = tree_model_iter_next;
 473   iface->get_path = tree_model_get_path;
 474   iface->get_value = tree_model_get_value;
 475
 476   iface->iter_children = 0;
 477   iface->iter_has_child =0;
 478   iface->iter_n_children =0;
 479   iface->iter_nth_child = tree_model_nth_child ;
 480   iface->iter_parent =0;
 481 }
 482
 483 static GtkTreeModelFlags
 484 tree_model_get_flags (GtkTreeModel *model)
 485 {
 486   g_return_val_if_fail (G_IS_PSPPIRE_DICT(model), (GtkTreeModelFlags) 0);
 487
 488   return GTK_TREE_MODEL_LIST_ONLY;
 489 }
 490
 491
 492 static gint
 493 tree_model_n_columns (GtkTreeModel *model)
 494 {
 495   return n_DICT_COLS;
 496 }
 497
 498 static GType
 499 tree_model_column_type (GtkTreeModel *model, gint index)
 500 {
 501   g_return_val_if_fail (G_IS_PSPPIRE_DICT(model), (GType) 0);
 502
 503   switch(index)
 504     {
 505     case DICT_TVM_COL_NAME:
 506       return G_TYPE_STRING;
 507       break;
 508     case DICT_TVM_COL_VAR:
 509       return G_TYPE_POINTER;
 510       break;
 511     default:
 512       g_return_val_if_reached((GType)0);
 513       break;
 514     }
 515
 516   g_assert_not_reached();
 517   return ((GType)0);
 518 }
 519
 520 static gboolean
 521 tree_model_get_iter(GtkTreeModel *model, GtkTreeIter *iter, GtkTreePath *path)
 522 {
 523   gint *indices, depth;
 524   gint n;
 525   struct variable *variable;
 526
 527   PsppireDict *dict = PSPPIRE_DICT (model);
 528
 529   g_return_val_if_fail (path, FALSE);
 530
 531   indices = gtk_tree_path_get_indices (path);
 532   depth = gtk_tree_path_get_depth (path);
 533
 534   g_return_val_if_fail(depth == 1, FALSE);
 535
 536   n = indices[0];
 537
 538   if ( n < 0 || n >= psppire_dict_get_var_cnt (dict))
 539     return FALSE;
 540
 541   variable = dict_get_var (dict->dict, n);
 542
 543   g_assert (var_get_dict_index (variable) == n);
 544
 545   iter->stamp = dict->stamp;
 546   iter->user_data = variable;
 547
 548   return TRUE;
 549 }
 550
 551
 552 static gboolean
 553 tree_model_iter_next(GtkTreeModel *model, GtkTreeIter *iter)
 554 {
 555   PsppireDict *dict = PSPPIRE_DICT (model);
 556   struct variable *variable;
 557   gint idx;
 558
 559   g_return_val_if_fail(iter->stamp == dict->stamp, FALSE);
 560
 561   if ( iter == NULL || iter->user_data == NULL)
 562     return FALSE;
 563
 564   variable = (struct variable *) iter->user_data;
 565
 566   idx = var_get_dict_index (variable);
 567
 568   if ( idx + 1 >= psppire_dict_get_var_cnt(dict))
 569     return FALSE;
 570
 571   variable = psppire_dict_get_variable (dict, idx + 1);
 572
 573   g_assert (var_get_dict_index (variable) == idx + 1);
 574
 575   iter->user_data = variable;
 576
 577   return TRUE;
 578 }
 579
 580 static GtkTreePath *
 581 tree_model_get_path(GtkTreeModel *model, GtkTreeIter *iter)
 582 {
 583   GtkTreePath *path;
 584   struct variable *variable;
 585   PsppireDict *dict = PSPPIRE_DICT (model);
 586
 587   g_return_val_if_fail(iter->stamp == dict->stamp, FALSE);
 588
 589   variable = (struct variable *) iter->user_data;
 590
 591   path = gtk_tree_path_new();
 592   gtk_tree_path_append_index(path, var_get_dict_index (variable));
 593
 594   return path;
 595 }
 596
 597
 598 static void
 599 tree_model_get_value(GtkTreeModel *model, GtkTreeIter *iter,
 600                      gint column, GValue *value)
 601 {
 602   struct variable *variable;
 603   PsppireDict *dict = PSPPIRE_DICT (model);
 604
 605   g_return_if_fail(iter->stamp == dict->stamp);
 606
 607   variable = (struct variable *) iter->user_data;
 608
 609   switch(column)
 610     {
 611     case DICT_TVM_COL_NAME:
 612       g_value_init(value, G_TYPE_STRING);
 613       g_value_set_string(value, var_get_name(variable));
 614       break;
 615     case DICT_TVM_COL_VAR:
 616       g_value_init(value, G_TYPE_POINTER);
 617       g_value_set_pointer(value, variable);
 618       break;
 619     default:
 620       g_return_if_reached();
 621       break;
 622     }
 623 }
 624
 625
 626 static gboolean
 627 tree_model_nth_child(GtkTreeModel *model, GtkTreeIter *iter,
 628                      GtkTreeIter *parent, gint n)
 629 {
 630   PsppireDict *dict;
 631   g_return_val_if_fail(G_IS_PSPPIRE_DICT(model), FALSE);
 632
 633   dict = PSPPIRE_DICT(model);
 634
 635   if ( parent )
 636     return FALSE;
 637
 638   if ( n >= psppire_dict_get_var_cnt(dict) )
 639     return FALSE;
 640
 641   iter->stamp = dict->stamp;
 642   iter->user_data = psppire_dict_get_variable(dict, n);
 643
 644   if ( !iter->user_data)
 645     return FALSE;
 646
 647
 648   return TRUE;
 649 }
 650
 651
 652 void
 653 psppire_dict_rename_var (PsppireDict *dict, struct variable *v,
 654                          const gchar *text)
 655 {
 656   dict_rename_var (dict->dict, v, text);
 657 }