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