src/ui/gui/compute-dialog.c

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