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
  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 };
  52
  53
  54 static void
  55 on_target_change (GObject *obj, struct compute_dialog *cd)
  56 {
  57   GtkWidget *target = get_widget_assert (cd->xml, "compute-entry1");
  58   GtkWidget *type_and_label = get_widget_assert (cd->xml, "compute-button1");
  59
  60   const gchar *var_name = gtk_entry_get_text (GTK_ENTRY (target));
  61   gboolean valid = var_name && strcmp ("", var_name);
  62
  63   gtk_widget_set_sensitive (type_and_label, valid);
  64 }
  65
  66 static void
  67 refresh (GObject *obj, const struct compute_dialog *cd)
  68 {
  69   GtkTextIter start, end;
  70   GtkWidget *target = get_widget_assert (cd->xml, "compute-entry1");
  71   GtkWidget *syntax_area = get_widget_assert (cd->xml, "compute-textview1");
  72   GtkWidget *varlist = get_widget_assert (cd->xml, "compute-treeview1");
  73   GtkWidget *funclist = get_widget_assert (cd->xml, "compute-treeview2");
  74
  75   GtkTextBuffer *buffer =
  76     gtk_text_view_get_buffer (GTK_TEXT_VIEW (syntax_area));
  77
  78   GtkTreeSelection *selection;
  79
  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
  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
  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   GladeXML *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   GladeXML *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   const 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 ( 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.",
 204                           target_name,
 205                           expression
 206                           );
 207
 208   text = string->str;
 209
 210   g_string_free (string, FALSE);
 211
 212   return text;
 213 }
 214
 215 static void
 216 reset_type_label_dialog (struct compute_dialog *cd)
 217 {
 218   const gchar *target_name;
 219   struct variable *target_var;
 220
 221   GtkWidget *width_entry =
 222     get_widget_assert (cd->xml, "type-and-label-width");
 223
 224   GtkWidget *label_entry =
 225     get_widget_assert (cd->xml, "type-and-label-label-entry");
 226
 227   GtkWidget *numeric_target =
 228     get_widget_assert (cd->xml, "radio-button-numeric");
 229
 230   GtkWidget *string_target =
 231     get_widget_assert (cd->xml, "radio-button-string");
 232
 233
 234   target_name = gtk_entry_get_text
 235     (GTK_ENTRY (get_widget_assert (cd->xml, "compute-entry1")));
 236
 237
 238   if ( (target_var = psppire_dict_lookup_var (cd->dict, target_name)) )
 239     {
 240       /* Existing Variable */
 241       const gchar *label ;
 242       GtkWidget *user_label =
 243         get_widget_assert (cd->xml, "radio-button-user-label");
 244
 245       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (user_label), TRUE);
 246
 247       label = var_get_label (target_var);
 248
 249       if ( label )
 250         {
 251           gtk_entry_set_text (GTK_ENTRY (label_entry), label);
 252         }
 253
 254       gtk_widget_set_sensitive (width_entry, FALSE);
 255
 256       if ( var_is_numeric (target_var))
 257         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (numeric_target),
 258                                       TRUE);
 259       else
 260         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (string_target),
 261                                       TRUE);
 262
 263       gtk_widget_set_sensitive (numeric_target, FALSE);
 264       gtk_widget_set_sensitive (string_target, FALSE);
 265     }
 266   else
 267     {
 268       GtkWidget *expression =
 269         get_widget_assert (cd->xml, "radio-button-expression-label");
 270
 271       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (expression), TRUE);
 272
 273       gtk_widget_set_sensitive (width_entry, TRUE);
 274       gtk_widget_set_sensitive (numeric_target, TRUE);
 275       gtk_widget_set_sensitive (string_target, TRUE);
 276
 277       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (numeric_target),
 278                                     TRUE);
 279     }
 280
 281 }
 282
 283 static void
 284 run_type_label_dialog (GtkButton *b, gpointer data)
 285 {
 286   struct compute_dialog *cd = data;
 287   gint response;
 288
 289   GtkWidget *subdialog = get_widget_assert (cd->xml, "type-and-label-dialog");
 290   GtkWidget *dialog = get_widget_assert (cd->xml, "compute-variable-dialog");
 291
 292   gtk_window_set_transient_for (GTK_WINDOW (subdialog), GTK_WINDOW (dialog));
 293
 294   reset_type_label_dialog (cd);
 295   response = psppire_dialog_run (PSPPIRE_DIALOG (subdialog));
 296 }
 297
 298
 299 static void
 300 on_expression_toggle (GtkToggleButton *button, gpointer data)
 301 {
 302   struct compute_dialog *cd = data;
 303
 304   GtkWidget *entry =
 305     get_widget_assert (cd->xml, "type-and-label-label-entry");
 306
 307   if ( gtk_toggle_button_get_active (button))
 308     {
 309       gtk_entry_set_text (GTK_ENTRY (entry), "");
 310       gtk_widget_set_sensitive (entry, FALSE);
 311     }
 312   else
 313     {
 314       const char *label;
 315       struct variable *target_var;
 316       const gchar *target_name = gtk_entry_get_text
 317         (GTK_ENTRY (get_widget_assert (cd->xml, "compute-entry1")));
 318
 319       target_var = psppire_dict_lookup_var (cd->dict, target_name);
 320       label = var_get_label (target_var);
 321
 322       if ( label )
 323         gtk_entry_set_text (GTK_ENTRY (entry), label);
 324
 325       gtk_widget_set_sensitive (entry, TRUE);
 326     }
 327 }
 328
 329 /* Pops up the Compute dialog box */
 330 void
 331 compute_dialog (GObject *o, gpointer data)
 332 {
 333   gint response;
 334   struct data_editor *de = data;
 335
 336   PsppireVarStore *vs;
 337   struct compute_dialog scd;
 338
 339   GladeXML *xml = XML_NEW ("psppire.glade");
 340
 341   GtkWidget *dialog = get_widget_assert   (xml, "compute-variable-dialog");
 342
 343   GtkWidget *dict_view = get_widget_assert (xml, "compute-treeview1");
 344   GtkWidget *functions = get_widget_assert (xml, "compute-treeview2");
 345   GtkWidget *keypad    = get_widget_assert (xml, "psppire-keypad1");
 346   GtkWidget *target    = get_widget_assert (xml, "compute-entry1");
 347   GtkWidget *syntax_area = get_widget_assert (xml, "compute-textview1");
 348   GtkWidget *var_selector = get_widget_assert (xml, "compute-selector1");
 349   GtkWidget *func_selector = get_widget_assert (xml, "compute-selector2");
 350   GtkWidget *type_and_label = get_widget_assert (xml, "compute-button1");
 351
 352   GtkWidget *expression =
 353         get_widget_assert (xml, "radio-button-expression-label");
 354
 355
 356   GtkSheet *var_sheet =
 357     GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 358
 359   vs = PSPPIRE_VAR_STORE (gtk_sheet_get_model (var_sheet));
 360
 361   scd.dict = vs->dict;
 362
 363   g_signal_connect (expression, "toggled",
 364                     G_CALLBACK(on_expression_toggle), &scd);
 365
 366   gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
 367
 368
 369   attach_dictionary_to_treeview (GTK_TREE_VIEW (dict_view),
 370                                  vs->dict,
 371                                  GTK_SELECTION_SINGLE, NULL);
 372
 373
 374   psppire_selector_set_subjects (PSPPIRE_SELECTOR (var_selector),
 375                                  dict_view, syntax_area,
 376                                  insert_source_row_into_text_view,
 377                                  NULL);
 378
 379
 380   function_list_populate (GTK_TREE_VIEW (functions));
 381
 382   psppire_selector_set_subjects (PSPPIRE_SELECTOR (func_selector),
 383                                  functions, syntax_area,
 384                                  insert_function_into_syntax_area,
 385                                  NULL);
 386
 387
 388   scd.xml = xml;
 389
 390   g_signal_connect (target, "changed", G_CALLBACK (on_target_change), &scd);
 391
 392   g_signal_connect (dialog, "refresh", G_CALLBACK (refresh),  &scd);
 393
 394   g_signal_connect (keypad, "insert-syntax",
 395                     G_CALLBACK (on_keypad_button),  xml);
 396
 397   g_signal_connect (keypad, "erase",
 398                     G_CALLBACK (erase),  xml);
 399
 400
 401   g_signal_connect (type_and_label, "clicked",
 402                     G_CALLBACK (run_type_label_dialog),  &scd);
 403
 404
 405
 406
 407   response = psppire_dialog_run (PSPPIRE_DIALOG (dialog));
 408
 409
 410   switch (response)
 411     {
 412     case GTK_RESPONSE_OK:
 413       {
 414         gchar *syntax = generate_syntax (&scd);
 415         struct getl_interface *sss = create_syntax_string_source (syntax);
 416         execute_syntax (sss);
 417
 418         g_free (syntax);
 419       }
 420       break;
 421     case PSPPIRE_RESPONSE_PASTE:
 422       {
 423         gchar *syntax = generate_syntax (&scd);
 424
 425         struct syntax_editor *se =
 426           (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
 427
 428         gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
 429
 430         g_free (syntax);
 431       }
 432       break;
 433     default:
 434       break;
 435     }
 436
 437   g_object_unref (xml);
 438 }
 439
 440
 441 enum {
 442   COL_NAME,
 443   COL_USAGE,
 444   COL_ARITY
 445 };
 446
 447
 448 static void
 449 function_list_populate (GtkTreeView *tv)
 450 {
 451   GtkListStore *liststore;
 452   GtkTreeIter iter;
 453   gint i;
 454
 455   const gint n_funcs = expr_get_function_cnt ();
 456
 457   liststore = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
 458
 459   for (i = 0 ; i < n_funcs ; ++i)
 460     {
 461       const struct operation *op = expr_get_function (i);
 462
 463       gtk_list_store_append (liststore, &iter);
 464
 465       gtk_list_store_set (liststore, &iter,
 466                           COL_NAME, expr_operation_get_name (op),
 467                           COL_USAGE, expr_operation_get_prototype (op),
 468                           COL_ARITY, expr_operation_get_arg_cnt (op),
 469                           -1);
 470     }
 471
 472
 473
 474   /* Set the cell rendering */
 475
 476   {
 477     GtkTreeViewColumn *col;
 478     GtkCellRenderer *renderer;
 479
 480
 481     col = gtk_tree_view_column_new ();
 482
 483     gtk_tree_view_append_column (tv, col);
 484
 485     renderer = gtk_cell_renderer_text_new ();
 486
 487     gtk_tree_view_column_pack_start (col, renderer, TRUE);
 488
 489     gtk_tree_view_column_add_attribute (col, renderer, "text", COL_USAGE);
 490   }
 491
 492   gtk_tree_view_set_model (tv, GTK_TREE_MODEL (liststore));
 493 }
 494
 495
 496
 497
 498 static void
 499 insert_function_into_syntax_area (GtkTreeIter iter,
 500                                   GtkWidget *text_view,
 501                                   GtkTreeModel *model
 502                                   )
 503 {
 504   GString *string;
 505   GValue name_value = {0};
 506   GValue arity_value = {0};
 507   gint arity;
 508   gint i;
 509
 510   GtkTextBuffer *buffer ;
 511
 512   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
 513
 514   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
 515
 516   gtk_tree_model_get_value (model, &iter, COL_NAME, &name_value);
 517   gtk_tree_model_get_value (model, &iter, COL_ARITY, &arity_value);
 518
 519   arity = g_value_get_int (&arity_value);
 520
 521   string = g_string_new (g_value_get_string (&name_value));
 522
 523   g_string_append (string, "(");
 524   for ( i = 0 ; i < arity -1 ; ++i )
 525     {
 526       g_string_append (string, "?,");
 527     }
 528   g_string_append (string, "?)");
 529
 530
 531   erase_selection (buffer);
 532
 533   gtk_text_buffer_insert_at_cursor (buffer, string->str, string->len);
 534
 535   g_value_unset (&name_value);
 536   g_value_unset (&arity_value);
 537   g_string_free (string, TRUE);
 538
 539   /* Now position the cursor over the first '?' */
 540   {
 541     GtkTextIter insert;
 542     GtkTextIter selectbound;
 543     GtkTextMark *cursor = gtk_text_buffer_get_insert (buffer);
 544     gtk_text_buffer_get_iter_at_mark (buffer, &insert, cursor);
 545     for ( i = 0 ; i < arity ; ++i )
 546       {
 547         gtk_text_iter_backward_cursor_position (&insert);
 548         gtk_text_iter_backward_cursor_position (&insert);
 549       }
 550     selectbound = insert;
 551     gtk_text_iter_forward_cursor_position (&selectbound);
 552
 553     gtk_text_buffer_select_range (buffer, &insert, &selectbound);
 554   }
 555
 556 }
 557
 558 /* Inserts the name of the selected variable into the destination widget.
 559    The destination widget must be a GtkTextView
 560  */
 561 static void
 562 insert_source_row_into_text_view (GtkTreeIter iter,
 563                                   GtkWidget *dest,
 564                                   GtkTreeModel *model
 565                                   )
 566 {
 567   GtkTreePath *path;
 568   PsppireDict *dict;
 569   gint *idx;
 570   struct variable *var;
 571   GtkTreeIter dict_iter;
 572   gchar *name;
 573   GtkTextBuffer *buffer;
 574
 575   g_return_if_fail (GTK_IS_TEXT_VIEW (dest));
 576
 577   if ( GTK_IS_TREE_MODEL_FILTER (model))
 578     {
 579       dict = PSPPIRE_DICT (gtk_tree_model_filter_get_model
 580                            (GTK_TREE_MODEL_FILTER(model)));
 581
 582       gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER
 583                                                         (model),
 584                                                         &dict_iter, &iter);
 585     }
 586   else
 587     {
 588       dict = PSPPIRE_DICT (model);
 589       dict_iter = iter;
 590     }
 591
 592   path = gtk_tree_model_get_path (GTK_TREE_MODEL (dict), &dict_iter);
 593
 594   idx = gtk_tree_path_get_indices (path);
 595
 596   var =  psppire_dict_get_variable (dict, *idx);
 597
 598   gtk_tree_path_free (path);
 599
 600   name = pspp_locale_to_utf8 (var_get_name (var), -1, NULL);
 601
 602   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (dest));
 603
 604   erase_selection (buffer);
 605
 606   gtk_text_buffer_insert_at_cursor (buffer, name, -1);
 607
 608   g_free (name);
 609 }