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