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 };
  51
  52
  53 static void
  54 on_target_change (GObject *obj, struct compute_dialog *cd)
  55 {
  56   GtkWidget *target = get_widget_assert (cd->xml, "compute-entry1");
  57   GtkWidget *type_and_label = get_widget_assert (cd->xml, "compute-button1");
  58
  59   const gchar *var_name = gtk_entry_get_text (GTK_ENTRY (target));
  60   gboolean valid = var_name && strcmp ("", var_name);
  61
  62   gtk_widget_set_sensitive (type_and_label, valid);
  63 }
  64
  65 static void
  66 refresh (GObject *obj, const struct compute_dialog *cd)
  67 {
  68   GtkTextIter start, end;
  69   GtkWidget *target = get_widget_assert (cd->xml, "compute-entry1");
  70   GtkWidget *syntax_area = get_widget_assert (cd->xml, "compute-textview1");
  71   GtkWidget *varlist = get_widget_assert (cd->xml, "compute-treeview1");
  72   GtkWidget *funclist = get_widget_assert (cd->xml, "compute-treeview2");
  73
  74   GtkTextBuffer *buffer =
  75     gtk_text_view_get_buffer (GTK_TEXT_VIEW (syntax_area));
  76
  77   GtkTreeSelection *selection;
  78
  79
  80   /* Clear the target variable entry box */
  81   gtk_entry_set_text (GTK_ENTRY (target), "");
  82   g_signal_emit_by_name (target, "changed");
  83
  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
  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   const 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 ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (string_toggle)))
 181     {
 182       const char *w = gtk_entry_get_text (GTK_ENTRY(width_entry));
 183       g_string_append_printf (string, "STRING %s (a%s).\n", target_name, w);
 184     }
 185   else
 186     g_string_append_printf (string, "NUMERIC %s.\n", target_name);
 187
 188   if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (user_label_toggle)))
 189     label = gtk_entry_get_text (GTK_ENTRY (label_entry));
 190   else
 191     label = expression;
 192
 193   if ( strlen (label) > 0 )
 194     g_string_append_printf (string, "VARIABLE LABEL %s '%s'.\n",
 195                             target_name,
 196                             label);
 197
 198   g_string_append_printf (string, "COMPUTE %s = %s.",
 199                           target_name,
 200                           expression
 201                           );
 202
 203   text = string->str;
 204
 205   g_string_free (string, FALSE);
 206
 207   return text;
 208 }
 209
 210 static void
 211 run_type_label_dialog (GtkButton *b, gpointer data)
 212 {
 213   struct compute_dialog *cd = data;
 214   gint response;
 215
 216   GtkWidget *subdialog = get_widget_assert (cd->xml, "type-and-label-dialog");
 217   GtkWidget *dialog = get_widget_assert (cd->xml, "compute-variable-dialog");
 218
 219   gtk_window_set_transient_for (GTK_WINDOW (subdialog), GTK_WINDOW (dialog));
 220
 221   response = psppire_dialog_run (PSPPIRE_DIALOG (subdialog));
 222 }
 223
 224
 225 /* Pops up the Compute dialog box */
 226 void
 227 compute_dialog (GObject *o, gpointer data)
 228 {
 229   gint response;
 230   struct data_editor *de = data;
 231
 232   PsppireVarStore *vs;
 233   struct compute_dialog scd;
 234
 235   GladeXML *xml = XML_NEW ("psppire.glade");
 236
 237   GtkWidget *dialog = get_widget_assert   (xml, "compute-variable-dialog");
 238
 239   GtkWidget *dict_view = get_widget_assert   (xml, "compute-treeview1");
 240   GtkWidget *functions = get_widget_assert   (xml, "compute-treeview2");
 241   GtkWidget *keypad =    get_widget_assert   (xml, "psppire-keypad1");
 242   GtkWidget *target =    get_widget_assert   (xml, "compute-entry1");
 243   GtkWidget *syntax_area = get_widget_assert (xml, "compute-textview1");
 244   GtkWidget *var_selector = get_widget_assert (xml, "compute-selector1");
 245   GtkWidget *func_selector = get_widget_assert (xml, "compute-selector2");
 246   GtkWidget *type_and_label = get_widget_assert (xml, "compute-button1");
 247
 248   GtkSheet *var_sheet =
 249     GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 250
 251   vs = PSPPIRE_VAR_STORE (gtk_sheet_get_model (var_sheet));
 252
 253
 254   gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
 255
 256
 257   attach_dictionary_to_treeview (GTK_TREE_VIEW (dict_view),
 258                                  vs->dict,
 259                                  GTK_SELECTION_SINGLE, NULL);
 260
 261
 262   psppire_selector_set_subjects (PSPPIRE_SELECTOR (var_selector),
 263                                  dict_view, syntax_area,
 264                                  insert_source_row_into_text_view,
 265                                  NULL);
 266
 267
 268   function_list_populate (GTK_TREE_VIEW (functions));
 269
 270   psppire_selector_set_subjects (PSPPIRE_SELECTOR (func_selector),
 271                                  functions, syntax_area,
 272                                  insert_function_into_syntax_area,
 273                                  NULL);
 274
 275
 276   scd.xml = xml;
 277
 278   g_signal_connect (target, "changed", G_CALLBACK (on_target_change), &scd);
 279
 280   g_signal_connect (dialog, "refresh", G_CALLBACK (refresh),  &scd);
 281
 282   g_signal_connect (keypad, "insert-syntax",
 283                     G_CALLBACK (on_keypad_button),  xml);
 284
 285   g_signal_connect (keypad, "erase",
 286                     G_CALLBACK (erase),  xml);
 287
 288
 289   g_signal_connect (type_and_label, "clicked",
 290                     G_CALLBACK (run_type_label_dialog),  &scd);
 291
 292
 293
 294   response = psppire_dialog_run (PSPPIRE_DIALOG (dialog));
 295
 296
 297   switch (response)
 298     {
 299     case GTK_RESPONSE_OK:
 300       {
 301         gchar *syntax = generate_syntax (&scd);
 302         struct getl_interface *sss = create_syntax_string_source (syntax);
 303         execute_syntax (sss);
 304
 305         g_free (syntax);
 306       }
 307       break;
 308     case PSPPIRE_RESPONSE_PASTE:
 309       {
 310         gchar *syntax = generate_syntax (&scd);
 311
 312         struct syntax_editor *se =
 313           (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
 314
 315         gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
 316
 317         g_free (syntax);
 318       }
 319       break;
 320     default:
 321       break;
 322     }
 323
 324   g_object_unref (xml);
 325 }
 326
 327
 328 enum {
 329   COL_NAME,
 330   COL_USAGE,
 331   COL_ARITY
 332 };
 333
 334
 335 static void
 336 function_list_populate (GtkTreeView *tv)
 337 {
 338   GtkListStore *liststore;
 339   GtkTreeIter iter;
 340   gint i;
 341
 342   const gint n_funcs = expr_get_function_cnt ();
 343
 344   liststore = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
 345
 346   for (i = 0 ; i < n_funcs ; ++i)
 347     {
 348       const struct operation *op = expr_get_function (i);
 349
 350       gtk_list_store_append (liststore, &iter);
 351
 352       gtk_list_store_set (liststore, &iter,
 353                           COL_NAME, expr_operation_get_name (op),
 354                           COL_USAGE, expr_operation_get_prototype (op),
 355                           COL_ARITY, expr_operation_get_arg_cnt (op),
 356                           -1);
 357     }
 358
 359
 360
 361   /* Set the cell rendering */
 362
 363   {
 364     GtkTreeViewColumn *col;
 365     GtkCellRenderer *renderer;
 366
 367
 368     col = gtk_tree_view_column_new ();
 369
 370     gtk_tree_view_append_column (tv, col);
 371
 372     renderer = gtk_cell_renderer_text_new ();
 373
 374     gtk_tree_view_column_pack_start (col, renderer, TRUE);
 375
 376     gtk_tree_view_column_add_attribute (col, renderer, "text", COL_USAGE);
 377   }
 378
 379   gtk_tree_view_set_model (tv, GTK_TREE_MODEL (liststore));
 380 }
 381
 382
 383
 384
 385 static void
 386 insert_function_into_syntax_area (GtkTreeIter iter,
 387                                   GtkWidget *text_view,
 388                                   GtkTreeModel *model
 389                                   )
 390 {
 391   GString *string;
 392   GValue name_value = {0};
 393   GValue arity_value = {0};
 394   gint arity;
 395   gint i;
 396
 397   GtkTextBuffer *buffer ;
 398
 399   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
 400
 401   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
 402
 403   gtk_tree_model_get_value (model, &iter, COL_NAME, &name_value);
 404   gtk_tree_model_get_value (model, &iter, COL_ARITY, &arity_value);
 405
 406   arity = g_value_get_int (&arity_value);
 407
 408   string = g_string_new (g_value_get_string (&name_value));
 409
 410   g_string_append (string, "(");
 411   for ( i = 0 ; i < arity -1 ; ++i )
 412     {
 413       g_string_append (string, "?,");
 414     }
 415   g_string_append (string, "?)");
 416
 417
 418   erase_selection (buffer);
 419
 420   gtk_text_buffer_insert_at_cursor (buffer, string->str, string->len);
 421
 422   g_value_unset (&name_value);
 423   g_value_unset (&arity_value);
 424   g_string_free (string, TRUE);
 425
 426   /* Now position the cursor over the first '?' */
 427   {
 428     GtkTextIter insert;
 429     GtkTextIter selectbound;
 430     GtkTextMark *cursor = gtk_text_buffer_get_insert (buffer);
 431     gtk_text_buffer_get_iter_at_mark (buffer, &insert, cursor);
 432     for ( i = 0 ; i < arity ; ++i )
 433       {
 434         gtk_text_iter_backward_cursor_position (&insert);
 435         gtk_text_iter_backward_cursor_position (&insert);
 436       }
 437     selectbound = insert;
 438     gtk_text_iter_forward_cursor_position (&selectbound);
 439
 440     gtk_text_buffer_select_range (buffer, &insert, &selectbound);
 441   }
 442
 443 }
 444
 445 /* Inserts the name of the selected variable into the destination widget.
 446    The destination widget must be a GtkTextView
 447  */
 448 static void
 449 insert_source_row_into_text_view (GtkTreeIter iter,
 450                                   GtkWidget *dest,
 451                                   GtkTreeModel *model
 452                                   )
 453 {
 454   GtkTreePath *path;
 455   PsppireDict *dict;
 456   gint *idx;
 457   struct variable *var;
 458   GtkTreeIter dict_iter;
 459   gchar *name;
 460   GtkTextBuffer *buffer;
 461
 462   g_return_if_fail (GTK_IS_TEXT_VIEW (dest));
 463
 464   if ( GTK_IS_TREE_MODEL_FILTER (model))
 465     {
 466       dict = PSPPIRE_DICT (gtk_tree_model_filter_get_model
 467                            (GTK_TREE_MODEL_FILTER(model)));
 468
 469       gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER
 470                                                         (model),
 471                                                         &dict_iter, &iter);
 472     }
 473   else
 474     {
 475       dict = PSPPIRE_DICT (model);
 476       dict_iter = iter;
 477     }
 478
 479   path = gtk_tree_model_get_path (GTK_TREE_MODEL (dict), &dict_iter);
 480
 481   idx = gtk_tree_path_get_indices (path);
 482
 483   var =  psppire_dict_get_variable (dict, *idx);
 484
 485   gtk_tree_path_free (path);
 486
 487   name = pspp_locale_to_utf8 (var_get_name (var), -1, NULL);
 488
 489   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (dest));
 490
 491   erase_selection (buffer);
 492
 493   gtk_text_buffer_insert_at_cursor (buffer, name, -1);
 494
 495   g_free (name);
 496 }