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