src/ui/gui/psppire-var-sheet.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2008 Free Software Foundation, Inc.
   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 "psppire-var-sheet.h"
  19 #include <ui/gui/sheet/psppire-axis-impl.h>
  20
  21 #include "helper.h"
  22
  23 #include "customentry.h"
  24 #include <data/variable.h>
  25 #include "psppire-var-store.h"
  26
  27 #include <gettext.h>
  28 #define _(msgid) gettext (msgid)
  29 #define N_(msgid) msgid
  30
  31
  32 static void psppire_var_sheet_class_init  (PsppireVarSheetClass *klass);
  33 static void psppire_var_sheet_init        (PsppireVarSheet      *vs);
  34
  35 enum
  36   {
  37     PSPPIRE_VAR_SHEET_MAY_CREATE_VARS = 1
  38   };
  39
  40 GType
  41 psppire_var_sheet_get_type (void)
  42 {
  43   static GType vs_type = 0;
  44
  45   if (!vs_type)
  46     {
  47       static const GTypeInfo vs_info =
  48       {
  49         sizeof (PsppireVarSheetClass),
  50         NULL, /* base_init */
  51         NULL, /* base_finalize */
  52         (GClassInitFunc) psppire_var_sheet_class_init,
  53         NULL, /* class_finalize */
  54         NULL, /* class_data */
  55         sizeof (PsppireVarSheet),
  56         0,
  57         (GInstanceInitFunc) psppire_var_sheet_init,
  58       };
  59
  60       vs_type = g_type_register_static (PSPPIRE_TYPE_SHEET, "PsppireVarSheet",
  61                                         &vs_info, 0);
  62     }
  63
  64   return vs_type;
  65 }
  66
  67 static GObjectClass * parent_class = NULL;
  68
  69 static void
  70 psppire_var_sheet_dispose (GObject *obj)
  71 {
  72   PsppireVarSheet *vs = (PsppireVarSheet *)obj;
  73
  74   if (vs->dispose_has_run)
  75     return;
  76
  77   /* Make sure dispose does not run twice. */
  78   vs->dispose_has_run = TRUE;
  79
  80   /* Chain up to the parent class */
  81   G_OBJECT_CLASS (parent_class)->dispose (obj);
  82 }
  83
  84 static void
  85 psppire_var_sheet_finalize (GObject *obj)
  86 {
  87    /* Chain up to the parent class */
  88    G_OBJECT_CLASS (parent_class)->finalize (obj);
  89 }
  90
  91
  92 struct column_parameters
  93 {
  94   gchar label[20];
  95   gint width ;
  96 };
  97
  98 #define n_ALIGNMENTS 3
  99
 100 const gchar *const alignments[n_ALIGNMENTS + 1]={
 101   N_("Left"),
 102   N_("Right"),
 103   N_("Center"),
 104   0
 105 };
 106
 107 const gchar *const measures[n_MEASURES + 1]={
 108   N_("Nominal"),
 109   N_("Ordinal"),
 110   N_("Scale"),
 111   0
 112 };
 113
 114
 115
 116 /* Create a list store from an array of strings */
 117 static GtkListStore *
 118 create_label_list (const gchar *const *labels)
 119 {
 120   const gchar *s;
 121   gint i = 0;
 122   GtkTreeIter iter;
 123
 124   GtkListStore *list_store;
 125   list_store = gtk_list_store_new (1, G_TYPE_STRING);
 126
 127
 128   while ( (s = labels[i++]))
 129     {
 130       gtk_list_store_append (list_store, &iter);
 131       gtk_list_store_set (list_store, &iter,
 132                           0, gettext (s),
 133                           -1);
 134     }
 135
 136   return list_store;
 137 }
 138
 139
 140 static void
 141 psppire_var_sheet_set_property (GObject      *object,
 142                                 guint         property_id,
 143                                 const GValue *value,
 144                                 GParamSpec   *pspec)
 145 {
 146   PsppireVarSheet *self = (PsppireVarSheet *) object;
 147
 148   switch (property_id)
 149     {
 150     case PSPPIRE_VAR_SHEET_MAY_CREATE_VARS:
 151       self->may_create_vars = g_value_get_boolean (value);
 152       break;
 153
 154     default:
 155       G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 156       break;
 157     }
 158 }
 159
 160 static void
 161 psppire_var_sheet_get_property (GObject      *object,
 162                                 guint         property_id,
 163                                 GValue       *value,
 164                                 GParamSpec   *pspec)
 165 {
 166   PsppireVarSheet *self = (PsppireVarSheet *) object;
 167
 168   switch (property_id)
 169     {
 170     case PSPPIRE_VAR_SHEET_MAY_CREATE_VARS:
 171       g_value_set_boolean (value, self->may_create_vars);
 172       break;
 173
 174     default:
 175       G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 176       break;
 177     }
 178 }
 179
 180
 181
 182 static void
 183 psppire_var_sheet_class_init (PsppireVarSheetClass *klass)
 184 {
 185   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 186   GParamSpec *pspec;
 187
 188   parent_class = g_type_class_peek_parent (klass);
 189
 190   object_class->dispose = psppire_var_sheet_dispose;
 191   object_class->finalize = psppire_var_sheet_finalize;
 192   object_class->set_property = psppire_var_sheet_set_property;
 193   object_class->get_property = psppire_var_sheet_get_property;
 194
 195   pspec = g_param_spec_boolean ("may-create-vars",
 196                                 "May create variables",
 197                                 "Whether the user may create more variables",
 198                                 TRUE,
 199                                 G_PARAM_READWRITE);
 200   g_object_class_install_property (object_class,
 201                                    PSPPIRE_VAR_SHEET_MAY_CREATE_VARS,
 202                                    pspec);
 203
 204   klass->measure_list = create_label_list (measures);
 205   klass->alignment_list = create_label_list (alignments);
 206 }
 207
 208
 209
 210 /* Callback for when the alignment combo box
 211    item is selected */
 212 static void
 213 change_alignment (GtkComboBox *cb,
 214                   struct variable *var)
 215 {
 216   gint active_item = gtk_combo_box_get_active (cb);
 217
 218   if ( active_item < 0 ) return ;
 219
 220   var_set_alignment (var, active_item);
 221 }
 222
 223
 224
 225 /* Callback for when the measure combo box
 226    item is selected */
 227 static void
 228 change_measure (GtkComboBox *cb,
 229                 struct variable *var)
 230 {
 231   gint active_item = gtk_combo_box_get_active (cb);
 232
 233   if ( active_item < 0 ) return ;
 234
 235   var_set_measure (var, active_item);
 236 }
 237
 238
 239 /* Moves the focus to a new cell.
 240    Returns TRUE iff the move should be disallowed */
 241 static gboolean
 242 traverse_cell_callback (PsppireSheet *sheet,
 243                         const PsppireSheetCell *existing_cell,
 244                         PsppireSheetCell *new_cell)
 245 {
 246   PsppireVarSheet *var_sheet = PSPPIRE_VAR_SHEET (sheet);
 247   PsppireVarStore *var_store = PSPPIRE_VAR_STORE (psppire_sheet_get_model (sheet));
 248
 249   gint n_vars = psppire_var_store_get_var_cnt (var_store);
 250
 251   if (new_cell->row >= n_vars && !var_sheet->may_create_vars)
 252     return TRUE;
 253
 254   if ( existing_cell->row == n_vars && new_cell->row >= n_vars)
 255     {
 256       GtkEntry *entry = psppire_sheet_get_entry (sheet);
 257
 258       const gchar *name = gtk_entry_get_text (entry);
 259
 260       if (! psppire_dict_check_name (var_store->dict, name, TRUE))
 261         return TRUE;
 262
 263       psppire_dict_insert_variable (var_store->dict, existing_cell->row, name);
 264
 265       return FALSE;
 266     }
 267
 268
 269   /* If the destination cell is outside the current  variables, then
 270      automatically create variables for the new rows.
 271   */
 272   if ( ((new_cell->row > n_vars) ||
 273         (new_cell->row == n_vars &&
 274          new_cell->col != PSPPIRE_VAR_STORE_COL_NAME)) )
 275     {
 276       gint i;
 277       for ( i = n_vars ; i <= new_cell->row; ++i )
 278         psppire_dict_insert_variable (var_store->dict, i, NULL);
 279     }
 280
 281   return FALSE;
 282 }
 283
 284
 285
 286
 287 /*
 288    Callback whenever the active cell changes on the var sheet.
 289 */
 290 static void
 291 var_sheet_change_active_cell (PsppireVarSheet *vs,
 292                               gint row, gint column,
 293                               gint oldrow, gint oldcolumn,
 294                               gpointer data)
 295 {
 296   PsppireSheetCellAttr attributes;
 297   PsppireVarStore *var_store;
 298   PsppireVarSheetClass *vs_class =
 299     PSPPIRE_VAR_SHEET_CLASS(G_OBJECT_GET_CLASS (vs));
 300
 301   struct variable *var ;
 302   PsppireSheet *sheet = PSPPIRE_SHEET (vs);
 303
 304   g_return_if_fail (sheet != NULL);
 305
 306   var_store = PSPPIRE_VAR_STORE (psppire_sheet_get_model (sheet));
 307
 308   g_assert (var_store);
 309
 310   g_return_if_fail (oldcolumn == PSPPIRE_VAR_STORE_COL_NAME ||
 311                     row < psppire_var_store_get_var_cnt (var_store));
 312
 313   psppire_sheet_get_attributes (sheet, row, column, &attributes);
 314
 315   var = psppire_var_store_get_var (var_store, row);
 316
 317   switch (column)
 318     {
 319     case PSPPIRE_VAR_STORE_COL_ALIGN:
 320       {
 321         GtkEntry *entry;
 322         static GtkListStore *list_store = NULL;
 323         GtkComboBoxEntry *cbe;
 324         psppire_sheet_change_entry (sheet, GTK_TYPE_COMBO_BOX_ENTRY);
 325         entry = psppire_sheet_get_entry (sheet);
 326         cbe = GTK_COMBO_BOX_ENTRY (GTK_WIDGET (entry)->parent);
 327
 328         if ( ! list_store) list_store = create_label_list (alignments);
 329
 330         gtk_combo_box_set_model (GTK_COMBO_BOX (cbe),
 331                                 GTK_TREE_MODEL (vs_class->alignment_list));
 332
 333         gtk_combo_box_entry_set_text_column (cbe, 0);
 334
 335         g_signal_connect (G_OBJECT (cbe),"changed",
 336                          G_CALLBACK (change_alignment), var);
 337       }
 338       break;
 339
 340     case PSPPIRE_VAR_STORE_COL_MEASURE:
 341       {
 342         GtkEntry *entry;
 343         GtkComboBoxEntry *cbe;
 344         psppire_sheet_change_entry (sheet, GTK_TYPE_COMBO_BOX_ENTRY);
 345         entry = psppire_sheet_get_entry (sheet);
 346         cbe = GTK_COMBO_BOX_ENTRY (GTK_WIDGET (entry)->parent);
 347
 348         gtk_combo_box_set_model (GTK_COMBO_BOX (cbe),
 349                                 GTK_TREE_MODEL (vs_class->measure_list));
 350
 351         gtk_combo_box_entry_set_text_column (cbe, 0);
 352
 353         g_signal_connect (G_OBJECT (cbe),"changed",
 354                           G_CALLBACK (change_measure), var);
 355       }
 356       break;
 357
 358     case PSPPIRE_VAR_STORE_COL_VALUES:
 359       {
 360         PsppireCustomEntry *customEntry;
 361
 362         psppire_sheet_change_entry (sheet, PSPPIRE_CUSTOM_ENTRY_TYPE);
 363
 364         customEntry =
 365           PSPPIRE_CUSTOM_ENTRY (psppire_sheet_get_entry (sheet));
 366
 367         if ( var_is_long_string (var))
 368           g_object_set (customEntry,
 369                         "editable", FALSE,
 370                         NULL);
 371
 372         val_labs_dialog_set_target_variable (vs->val_labs_dialog, var);
 373
 374         g_signal_connect_swapped (customEntry,
 375                                   "clicked",
 376                                   G_CALLBACK (val_labs_dialog_show),
 377                                   vs->val_labs_dialog);
 378       }
 379       break;
 380
 381     case PSPPIRE_VAR_STORE_COL_MISSING:
 382       {
 383         PsppireCustomEntry *customEntry;
 384
 385         psppire_sheet_change_entry (sheet, PSPPIRE_CUSTOM_ENTRY_TYPE);
 386
 387         customEntry =
 388           PSPPIRE_CUSTOM_ENTRY (psppire_sheet_get_entry (sheet));
 389
 390         if ( var_is_long_string (var))
 391           g_object_set (customEntry,
 392                         "editable", FALSE,
 393                         NULL);
 394
 395
 396         vs->missing_val_dialog->pv =
 397           psppire_var_store_get_var (var_store, row);
 398
 399         g_signal_connect_swapped (customEntry,
 400                                   "clicked",
 401                                   G_CALLBACK (missing_val_dialog_show),
 402                                   vs->missing_val_dialog);
 403       }
 404       break;
 405
 406     case PSPPIRE_VAR_STORE_COL_TYPE:
 407       {
 408         PsppireCustomEntry *customEntry;
 409
 410         psppire_sheet_change_entry (sheet, PSPPIRE_CUSTOM_ENTRY_TYPE);
 411
 412         customEntry =
 413           PSPPIRE_CUSTOM_ENTRY (psppire_sheet_get_entry (sheet));
 414
 415
 416         /* Popup the Variable Type dialog box */
 417         vs->var_type_dialog->pv = var;
 418
 419         g_signal_connect_swapped (customEntry,
 420                                  "clicked",
 421                                  G_CALLBACK (var_type_dialog_show),
 422                                   vs->var_type_dialog);
 423       }
 424       break;
 425
 426     case PSPPIRE_VAR_STORE_COL_WIDTH:
 427     case PSPPIRE_VAR_STORE_COL_DECIMALS:
 428     case PSPPIRE_VAR_STORE_COL_COLUMNS:
 429       {
 430         if ( attributes.is_editable)
 431           {
 432             gint r_min, r_max;
 433
 434             const gchar *s = psppire_sheet_cell_get_text (sheet, row, column);
 435
 436             if (s)
 437               {
 438                 GtkSpinButton *spinButton ;
 439                 const gint current_value  = g_strtod (s, NULL);
 440                 GtkObject *adj ;
 441
 442                 const struct fmt_spec *fmt = var_get_write_format (var);
 443                 switch (column)
 444                   {
 445                   case PSPPIRE_VAR_STORE_COL_WIDTH:
 446                     r_min = MAX (fmt->d + 1, fmt_min_output_width (fmt->type));
 447                     r_max = fmt_max_output_width (fmt->type);
 448                     break;
 449                   case PSPPIRE_VAR_STORE_COL_DECIMALS:
 450                     r_min = 0 ;
 451                     r_max = fmt_max_output_decimals (fmt->type, fmt->w);
 452                     break;
 453                   case PSPPIRE_VAR_STORE_COL_COLUMNS:
 454                     r_min = 1;
 455                     r_max = 255 ; /* Is this a sensible value ? */
 456                     break;
 457                   default:
 458                     g_assert_not_reached ();
 459                   }
 460
 461                 adj = gtk_adjustment_new (current_value,
 462                                          r_min, r_max,
 463                                          1.0, 1.0, 1.0 /* steps */
 464                                          );
 465
 466                 psppire_sheet_change_entry (sheet, GTK_TYPE_SPIN_BUTTON);
 467
 468                 spinButton =
 469                   GTK_SPIN_BUTTON (psppire_sheet_get_entry (sheet));
 470
 471                 gtk_spin_button_set_adjustment (spinButton, GTK_ADJUSTMENT (adj));
 472                 gtk_spin_button_set_digits (spinButton, 0);
 473               }
 474           }
 475       }
 476       break;
 477
 478     default:
 479       psppire_sheet_change_entry (sheet, GTK_TYPE_ENTRY);
 480       break;
 481     }
 482 }
 483
 484
 485 static void
 486 psppire_var_sheet_init (PsppireVarSheet *vs)
 487 {
 488   GtkBuilder *builder = builder_new ("data-editor.ui");
 489
 490   vs->val_labs_dialog = val_labs_dialog_create (builder);
 491   vs->missing_val_dialog = missing_val_dialog_create (builder);
 492   vs->var_type_dialog = var_type_dialog_create (builder);
 493
 494   connect_help (builder);
 495
 496   g_object_unref (builder);
 497
 498   vs->dispose_has_run = FALSE;
 499   vs->may_create_vars = TRUE;
 500
 501   g_signal_connect (vs, "activate",
 502                     G_CALLBACK (var_sheet_change_active_cell),
 503                     NULL);
 504
 505   g_signal_connect (vs, "traverse",
 506                     G_CALLBACK (traverse_cell_callback), NULL);
 507 }
 508
 509
 510 static const struct column_parameters column_def[] = {
 511   { N_("Name"),    80},
 512   { N_("Type"),    100},
 513   { N_("Width"),   57},
 514   { N_("Decimals"),91},
 515   { N_("Label"),   95},
 516   { N_("Values"),  103},
 517   { N_("Missing"), 95},
 518   { N_("Columns"), 80},
 519   { N_("Align"),   69},
 520   { N_("Measure"), 99},
 521 };
 522
 523 GtkWidget*
 524 psppire_var_sheet_new (void)
 525 {
 526   gint i;
 527   PsppireAxisImpl *ha = psppire_axis_impl_new ();
 528   PsppireAxisImpl *va = psppire_axis_impl_new ();
 529
 530   GtkWidget *w = g_object_new (psppire_var_sheet_get_type (), NULL);
 531
 532   for (i = 0 ; i < 10 ; ++i)
 533     psppire_axis_impl_append (ha, column_def[i].width);
 534
 535   g_object_set (va,
 536                 "default-size", 25,
 537                 NULL);
 538
 539   g_object_set (ha, "minimum-extent", 0,
 540                 NULL);
 541
 542   g_object_set (w,
 543                 "horizontal-axis", ha,
 544                 "vertical-axis", va,
 545                 NULL);
 546
 547   return w;
 548 }