pintos-os.org Git - pspp/blob - src/ui/gui/compute-dialog.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2007, 2010, 2011, 2012  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 <gtk/gtk.h>
  19 #include "compute-dialog.h"
  20 #include "builder-wrapper.h"
  21 #include "psppire-dialog.h"
  22 #include "psppire-keypad.h"
  23 #include "psppire-data-window.h"
  24 #include "psppire-var-store.h"
  25 #include "psppire-selector.h"
  26 #include "dialog-common.h"
  27 #include <libpspp/i18n.h>
  28
  29
  30 #include <language/expressions/public.h>
  31 #include "executor.h"
  32 #include "helper.h"
  33
  34
  35 static void function_list_populate (GtkTreeView *tv);
  36
  37 static void insert_function_into_syntax_area (GtkTreeIter iter,
  38                                               GtkWidget *text_view,
  39                                               GtkTreeModel *model,
  40                                               gpointer data
  41                                               );
  42
  43 static void insert_source_row_into_text_view (GtkTreeIter iter,
  44                                               GtkWidget *dest,
  45                                               GtkTreeModel *model,
  46                                               gpointer data
  47                                               );
  48
  49
  50
  51 struct compute_dialog
  52 {
  53   GtkBuilder *xml;  /* The xml that generated the widgets */
  54   PsppireDict *dict;
  55   gboolean use_type;
  56 };
  57
  58
  59 static void
  60 on_target_change (GObject *obj, struct compute_dialog *cd)
  61 {
  62   GtkWidget *target = get_widget_assert (cd->xml, "compute-entry1");
  63   GtkWidget *type_and_label = get_widget_assert (cd->xml, "compute-button1");
  64
  65   const gchar *var_name = gtk_entry_get_text (GTK_ENTRY (target));
  66   gboolean valid = var_name && strcmp ("", var_name);
  67
  68   gtk_widget_set_sensitive (type_and_label, valid);
  69 }
  70
  71 static void
  72 refresh (GObject *obj, const struct compute_dialog *cd)
  73 {
  74   GtkTextIter start, end;
  75   GtkWidget *target = get_widget_assert (cd->xml, "compute-entry1");
  76   GtkWidget *syntax_area = get_widget_assert (cd->xml, "compute-textview1");
  77   GtkWidget *varlist = get_widget_assert (cd->xml, "compute-treeview1");
  78   GtkWidget *funclist = get_widget_assert (cd->xml, "compute-treeview2");
  79
  80   GtkTextBuffer *buffer =
  81     gtk_text_view_get_buffer (GTK_TEXT_VIEW (syntax_area));
  82
  83   GtkTreeSelection *selection;
  84
  85   /* Clear the target variable entry box */
  86   gtk_entry_set_text (GTK_ENTRY (target), "");
  87   g_signal_emit_by_name (target, "changed");
  88
  89   /* Clear the syntax area textbuffer */
  90   gtk_text_buffer_get_start_iter (buffer, &start);
  91   gtk_text_buffer_get_end_iter (buffer, &end);
  92   gtk_text_buffer_delete (buffer, &start, &end);
  93
  94   /* Unselect all items in the treeview */
  95   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (varlist));
  96   gtk_tree_selection_unselect_all (selection);
  97
  98   /* And the other one */
  99   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (funclist));
 100   gtk_tree_selection_unselect_all (selection);
 101 }
 102
 103
 104 static void
 105 erase_selection (GtkTextBuffer *buffer)
 106 {
 107   GtkTextIter start, end;
 108
 109   gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
 110
 111   gtk_text_buffer_delete (buffer, &start, &end);
 112 }
 113
 114
 115
 116 static void
 117 on_keypad_button (PsppireKeypad *kp, const gchar *syntax, gpointer data)
 118 {
 119   GtkBuilder *xml = data;
 120
 121   GtkWidget *rhs = get_widget_assert (xml, "compute-textview1");
 122
 123   GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (rhs));
 124
 125   erase_selection (buffer);
 126
 127   gtk_text_buffer_insert_at_cursor (buffer, syntax, strlen (syntax));
 128
 129   if (0 == strcmp (syntax, "()"))
 130     {
 131       GtkTextIter iter;
 132       GtkTextMark *cursor = gtk_text_buffer_get_insert (buffer);
 133       gtk_text_buffer_get_iter_at_mark (buffer, &iter, cursor);
 134       gtk_text_iter_backward_cursor_position (&iter);
 135       gtk_text_buffer_move_mark (buffer, cursor, &iter);
 136     }
 137
 138 }
 139
 140 static void
 141 erase (PsppireKeypad *kp, gpointer data)
 142 {
 143   GtkBuilder *xml = data;
 144
 145   GtkWidget *rhs = get_widget_assert (xml, "compute-textview1");
 146
 147   GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (rhs));
 148
 149   erase_selection (buffer);
 150 }
 151
 152 static char *
 153 generate_syntax (const struct compute_dialog *cd)
 154 {
 155   gchar *text;
 156   GString *string ;
 157   const gchar *target_name ;
 158   gchar *expression;
 159   const gchar *label;
 160   GtkTextIter start, end;
 161   GtkWidget *target = get_widget_assert   (cd->xml, "compute-entry1");
 162   GtkWidget *syntax_area = get_widget_assert (cd->xml, "compute-textview1");
 163   GtkWidget *string_toggle = get_widget_assert (cd->xml, "radio-button-string");
 164   GtkWidget *user_label_toggle =
 165     get_widget_assert (cd->xml, "radio-button-user-label");
 166   GtkWidget *width_entry = get_widget_assert (cd->xml, "type-and-label-width");
 167   GtkWidget *label_entry = get_widget_assert (cd->xml,
 168                                               "type-and-label-label-entry");
 169
 170
 171   GtkTextBuffer *buffer =
 172     gtk_text_view_get_buffer (GTK_TEXT_VIEW (syntax_area));
 173
 174   gtk_text_buffer_get_start_iter (buffer, &start);
 175   gtk_text_buffer_get_end_iter (buffer, &end);
 176
 177   target_name = gtk_entry_get_text (GTK_ENTRY (target));
 178
 179   expression = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
 180
 181   string = g_string_sized_new (64);
 182
 183   if ( cd-> use_type &&
 184        NULL == psppire_dict_lookup_var (cd->dict, target_name ))
 185     {
 186       if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (string_toggle)))
 187         {
 188           const char *w = gtk_entry_get_text (GTK_ENTRY(width_entry));
 189           g_string_append_printf (string,
 190                                   "STRING %s (a%s).\n", target_name, w);
 191         }
 192       else
 193         g_string_append_printf (string, "NUMERIC %s.\n", target_name);
 194     }
 195
 196   if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (user_label_toggle)))
 197     label = gtk_entry_get_text (GTK_ENTRY (label_entry));
 198   else
 199     label = expression;
 200
 201   if ( strlen (label) > 0 )
 202     g_string_append_printf (string, "VARIABLE LABEL %s '%s'.\n",
 203                             target_name,
 204                             label);
 205
 206   g_string_append_printf (string, "COMPUTE %s = %s.\n",
 207                           target_name,
 208                           expression
 209                           );
 210
 211   g_string_append (string, "EXECUTE.\n");
 212
 213
 214   g_free (expression);
 215
 216   text = string->str;
 217
 218   g_string_free (string, FALSE);
 219
 220   return text;
 221 }
 222
 223 static void
 224 reset_type_label_dialog (struct compute_dialog *cd)
 225 {
 226   const gchar *target_name;
 227   struct variable *target_var;
 228
 229   GtkWidget *width_entry =
 230     get_widget_assert (cd->xml, "type-and-label-width");
 231
 232   GtkWidget *label_entry =
 233     get_widget_assert (cd->xml, "type-and-label-label-entry");
 234
 235   GtkWidget *numeric_target =
 236     get_widget_assert (cd->xml, "radio-button-numeric");
 237
 238   GtkWidget *string_target =
 239     get_widget_assert (cd->xml, "radio-button-string");
 240
 241
 242   target_name = gtk_entry_get_text
 243     (GTK_ENTRY (get_widget_assert (cd->xml, "compute-entry1")));
 244
 245
 246   if ( (target_var = psppire_dict_lookup_var (cd->dict, target_name)) )
 247     {
 248       /* Existing Variable */
 249       const gchar *label ;
 250       GtkWidget *user_label =
 251         get_widget_assert (cd->xml, "radio-button-user-label");
 252
 253       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (user_label), TRUE);
 254
 255       label = var_get_label (target_var);
 256
 257       if ( label )
 258         {
 259           gtk_entry_set_text (GTK_ENTRY (label_entry), label);
 260         }
 261
 262       gtk_widget_set_sensitive (width_entry, FALSE);
 263
 264       if ( var_is_numeric (target_var))
 265         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (numeric_target),
 266                                       TRUE);
 267       else
 268         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (string_target),
 269                                       TRUE);
 270
 271       gtk_widget_set_sensitive (numeric_target, FALSE);
 272       gtk_widget_set_sensitive (string_target, FALSE);
 273     }
 274   else
 275     {
 276       GtkWidget *expression =
 277         get_widget_assert (cd->xml, "radio-button-expression-label");
 278
 279       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (expression), TRUE);
 280
 281       gtk_widget_set_sensitive (width_entry, TRUE);
 282       gtk_widget_set_sensitive (numeric_target, TRUE);
 283       gtk_widget_set_sensitive (string_target, TRUE);
 284
 285       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (numeric_target),
 286                                     TRUE);
 287     }
 288
 289 }
 290
 291 static void
 292 run_type_label_dialog (GtkButton *b, gpointer data)
 293 {
 294   struct compute_dialog *cd = data;
 295   gint response;
 296
 297   GtkWidget *subdialog = get_widget_assert (cd->xml, "type-and-label-dialog");
 298   GtkWidget *dialog = get_widget_assert (cd->xml, "compute-variable-dialog");
 299
 300   gtk_window_set_transient_for (GTK_WINDOW (subdialog), GTK_WINDOW (dialog));
 301
 302   reset_type_label_dialog (cd);
 303   response = psppire_dialog_run (PSPPIRE_DIALOG (subdialog));
 304   if ( response == PSPPIRE_RESPONSE_CONTINUE)
 305     cd->use_type = TRUE;
 306 }
 307
 308 static void
 309 on_type_toggled (GtkToggleButton *button, gpointer data)
 310 {
 311   struct compute_dialog *cd = data;
 312
 313   GtkWidget *entry =
 314     get_widget_assert (cd->xml, "type-and-label-width");
 315
 316   if ( gtk_toggle_button_get_active (button))
 317     {
 318       gtk_widget_set_sensitive (entry, TRUE);
 319       gtk_widget_grab_focus (entry);
 320     }
 321   else
 322     {
 323       gtk_widget_set_sensitive (entry, FALSE);
 324     }
 325 }
 326
 327 static void
 328 on_expression_toggle (GtkToggleButton *button, gpointer data)
 329 {
 330   struct compute_dialog *cd = data;
 331
 332   GtkWidget *entry =
 333     get_widget_assert (cd->xml, "type-and-label-label-entry");
 334
 335   if ( gtk_toggle_button_get_active (button))
 336     {
 337       gtk_entry_set_text (GTK_ENTRY (entry), "");
 338       gtk_widget_set_sensitive (entry, FALSE);
 339     }
 340   else
 341     {
 342       struct variable *target_var;
 343       const gchar *target_name = gtk_entry_get_text
 344         (GTK_ENTRY (get_widget_assert (cd->xml, "compute-entry1")));
 345
 346       target_var = psppire_dict_lookup_var (cd->dict, target_name);
 347       if ( target_var )
 348         {
 349           const char *label = var_get_label (target_var);
 350
 351           if ( label )
 352             gtk_entry_set_text (GTK_ENTRY (entry), label);
 353         }
 354       else
 355         gtk_entry_set_text (GTK_ENTRY (entry), "");
 356
 357       gtk_widget_set_sensitive (entry, TRUE);
 358       gtk_widget_grab_focus (entry);
 359     }
 360 }
 361
 362
 363 /* Return TRUE if the dialog box's widgets' state are such that clicking OK
 364    might not result in erroneous syntax being generated */
 365 static gboolean
 366 contents_plausible (gpointer data)
 367 {
 368   struct compute_dialog *cd = data;
 369
 370   GtkWidget *target      = get_widget_assert (cd->xml, "compute-entry1");
 371   GtkWidget *syntax_area = get_widget_assert (cd->xml, "compute-textview1");
 372   GtkTextBuffer *buffer  =
 373     gtk_text_view_get_buffer (GTK_TEXT_VIEW (syntax_area));
 374
 375   if ( 0 == strcmp ("", gtk_entry_get_text (GTK_ENTRY (target))))
 376     return FALSE;
 377
 378   if ( gtk_text_buffer_get_char_count (buffer) == 0 )
 379     return FALSE;
 380
 381   return TRUE;
 382 }
 383
 384 /* Pops up the Compute dialog box */
 385 void
 386 compute_dialog (PsppireDataWindow *de)
 387 {
 388   gint response;
 389
 390   PsppireVarStore *vs = NULL;
 391   struct compute_dialog scd;
 392
 393   GtkBuilder *xml = builder_new ("compute.ui");
 394
 395   GtkWidget *dialog = get_widget_assert   (xml, "compute-variable-dialog");
 396
 397   GtkWidget *dict_view = get_widget_assert (xml, "compute-treeview1");
 398   GtkWidget *functions = get_widget_assert (xml, "compute-treeview2");
 399   GtkWidget *keypad    = get_widget_assert (xml, "psppire-keypad1");
 400   GtkWidget *target    = get_widget_assert (xml, "compute-entry1");
 401   GtkWidget *var_selector = get_widget_assert (xml, "compute-selector1");
 402   GtkWidget *func_selector = get_widget_assert (xml, "compute-selector2");
 403   GtkWidget *type_and_label = get_widget_assert (xml, "compute-button1");
 404
 405   GtkWidget *expression =
 406         get_widget_assert (xml, "radio-button-expression-label");
 407
 408   GtkWidget *str_btn =
 409         get_widget_assert (xml, "radio-button-string");
 410
 411
 412   g_object_get (de->data_editor, "var-store", &vs, NULL);
 413   g_object_get (vs, "dictionary", &scd.dict, NULL);
 414   scd.use_type = FALSE;
 415
 416   g_signal_connect (expression, "toggled",
 417                     G_CALLBACK(on_expression_toggle), &scd);
 418
 419   g_signal_connect (str_btn, "toggled",
 420                     G_CALLBACK(on_type_toggled), &scd);
 421
 422   gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
 423
 424
 425   g_object_set (dict_view, "model", scd.dict,
 426                 "selection-mode", GTK_SELECTION_SINGLE,
 427                 NULL);
 428
 429   psppire_selector_set_select_func (PSPPIRE_SELECTOR (var_selector),
 430                                     insert_source_row_into_text_view, NULL);
 431
 432   function_list_populate (GTK_TREE_VIEW (functions));
 433
 434   psppire_selector_set_select_func (PSPPIRE_SELECTOR (func_selector),
 435                                     insert_function_into_syntax_area, NULL);
 436
 437   scd.xml = xml;
 438
 439   psppire_dialog_set_valid_predicate (PSPPIRE_DIALOG (dialog),
 440                                       contents_plausible, &scd);
 441
 442   g_signal_connect (target, "changed", G_CALLBACK (on_target_change), &scd);
 443
 444   g_signal_connect (dialog, "refresh", G_CALLBACK (refresh),  &scd);
 445
 446   g_signal_connect (keypad, "insert-syntax",
 447                     G_CALLBACK (on_keypad_button),  xml);
 448
 449   g_signal_connect (keypad, "erase",
 450                     G_CALLBACK (erase),  xml);
 451
 452
 453   g_signal_connect (type_and_label, "clicked",
 454                     G_CALLBACK (run_type_label_dialog),  &scd);
 455
 456
 457
 458   response = psppire_dialog_run (PSPPIRE_DIALOG (dialog));
 459
 460
 461   switch (response)
 462     {
 463     case GTK_RESPONSE_OK:
 464       g_free (execute_syntax_string (de, generate_syntax (&scd)));
 465       break;
 466     case PSPPIRE_RESPONSE_PASTE:
 467       g_free (paste_syntax_to_window (generate_syntax (&scd)));
 468       break;
 469     default:
 470       break;
 471     }
 472
 473   g_object_unref (xml);
 474 }
 475
 476
 477 enum {
 478   COMPUTE_COL_NAME,
 479   COMPUTE_COL_USAGE,
 480   COMPUTE_COL_ARITY
 481 };
 482
 483
 484 static void
 485 function_list_populate (GtkTreeView *tv)
 486 {
 487   GtkListStore *liststore;
 488   GtkTreeIter iter;
 489   gint i;
 490
 491   const gint n_funcs = expr_get_function_cnt ();
 492
 493   liststore = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
 494
 495   for (i = 0 ; i < n_funcs ; ++i)
 496     {
 497       const struct operation *op = expr_get_function (i);
 498
 499       gtk_list_store_append (liststore, &iter);
 500
 501       gtk_list_store_set (liststore, &iter,
 502                           COMPUTE_COL_NAME, expr_operation_get_name (op),
 503                           COMPUTE_COL_USAGE, expr_operation_get_prototype (op),
 504                           COMPUTE_COL_ARITY, expr_operation_get_arg_cnt (op),
 505                           -1);
 506     }
 507
 508
 509
 510   /* Set the cell rendering */
 511
 512   {
 513     GtkTreeViewColumn *col;
 514     GtkCellRenderer *renderer;
 515
 516
 517     col = gtk_tree_view_column_new ();
 518
 519     gtk_tree_view_append_column (tv, col);
 520
 521     renderer = gtk_cell_renderer_text_new ();
 522
 523     gtk_tree_view_column_pack_start (col, renderer, TRUE);
 524
 525     gtk_tree_view_column_add_attribute (col, renderer, "text", COMPUTE_COL_USAGE);
 526   }
 527
 528   gtk_tree_view_set_model (tv, GTK_TREE_MODEL (liststore));
 529   g_object_unref (liststore);
 530 }
 531
 532
 533
 534
 535 static void
 536 insert_function_into_syntax_area (GtkTreeIter iter,
 537                                   GtkWidget *text_view,
 538                                   GtkTreeModel *model,
 539                                   gpointer data
 540                                   )
 541 {
 542   GString *string;
 543   GValue name_value = {0};
 544   GValue arity_value = {0};
 545   gint arity;
 546   gint i;
 547
 548   GtkTextBuffer *buffer ;
 549
 550   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
 551
 552   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
 553
 554   gtk_tree_model_get_value (model, &iter, COMPUTE_COL_NAME, &name_value);
 555   gtk_tree_model_get_value (model, &iter, COMPUTE_COL_ARITY, &arity_value);
 556
 557   arity = g_value_get_int (&arity_value);
 558
 559   string = g_string_new (g_value_get_string (&name_value));
 560
 561   g_string_append (string, "(");
 562   for ( i = 0 ; i < arity -1 ; ++i )
 563     {
 564       g_string_append (string, "?,");
 565     }
 566   g_string_append (string, "?)");
 567
 568
 569   erase_selection (buffer);
 570
 571   gtk_text_buffer_insert_at_cursor (buffer, string->str, string->len);
 572
 573   g_value_unset (&name_value);
 574   g_value_unset (&arity_value);
 575   g_string_free (string, TRUE);
 576
 577   /* Now position the cursor over the first '?' */
 578   {
 579     GtkTextIter insert;
 580     GtkTextIter selectbound;
 581     GtkTextMark *cursor = gtk_text_buffer_get_insert (buffer);
 582     gtk_text_buffer_get_iter_at_mark (buffer, &insert, cursor);
 583     for ( i = 0 ; i < arity ; ++i )
 584       {
 585         gtk_text_iter_backward_cursor_position (&insert);
 586         gtk_text_iter_backward_cursor_position (&insert);
 587       }
 588     selectbound = insert;
 589     gtk_text_iter_forward_cursor_position (&selectbound);
 590
 591     gtk_text_buffer_select_range (buffer, &insert, &selectbound);
 592   }
 593
 594 }
 595
 596 /* Inserts the name of the selected variable into the destination widget.
 597    The destination widget must be a GtkTextView
 598  */
 599 static void
 600 insert_source_row_into_text_view (GtkTreeIter iter,
 601                                   GtkWidget *dest,
 602                                   GtkTreeModel *model,
 603                                   gpointer data
 604                                   )
 605 {
 606   GtkTreePath *path;
 607   PsppireDict *dict;
 608   gint *idx;
 609   struct variable *var;
 610   GtkTreeIter dict_iter;
 611   GtkTextBuffer *buffer;
 612
 613   g_return_if_fail (GTK_IS_TEXT_VIEW (dest));
 614
 615   if ( GTK_IS_TREE_MODEL_FILTER (model))
 616     {
 617       dict = PSPPIRE_DICT (gtk_tree_model_filter_get_model
 618                            (GTK_TREE_MODEL_FILTER(model)));
 619
 620       gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER
 621                                                         (model),
 622                                                         &dict_iter, &iter);
 623     }
 624   else
 625     {
 626       dict = PSPPIRE_DICT (model);
 627       dict_iter = iter;
 628     }
 629
 630   path = gtk_tree_model_get_path (GTK_TREE_MODEL (dict), &dict_iter);
 631
 632   idx = gtk_tree_path_get_indices (path);
 633
 634   var =  psppire_dict_get_variable (dict, *idx);
 635
 636   gtk_tree_path_free (path);
 637
 638   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (dest));
 639
 640   erase_selection (buffer);
 641
 642   gtk_text_buffer_insert_at_cursor (buffer, var_get_name (var), -1);
 643
 644 }