src/ui/gui/compute-dialog.c

   1 /*
   2     PSPPIRE --- A Graphical User Interface for PSPP
   3     Copyright (C) 2007  Free Software Foundation
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18     02110-1301, USA. */
  19
  20
  21 #include <gtk/gtk.h>
  22 #include "compute-dialog.h"
  23 #include "helper.h"
  24 #include "psppire-dialog.h"
  25 #include "psppire-keypad.h"
  26 #include "data-editor.h"
  27 #include <gtksheet/gtksheet.h>
  28 #include "psppire-var-store.h"
  29 #include "dialog-common.h"
  30 #include "dict-display.h"
  31
  32 #include <language/expressions/public.h>
  33 #include <language/syntax-string-source.h>
  34 #include "syntax-editor.h"
  35
  36 static void function_list_populate (GtkTreeView *tv);
  37
  38 static void insert_function_into_syntax_area (GtkTreeIter iter,
  39                                               GtkWidget *text_view,
  40                                               GtkTreeModel *model
  41                                               );
  42
  43 static void insert_source_row_into_text_view (GtkTreeIter iter,
  44                                               GtkWidget *dest,
  45                                               GtkTreeModel *model
  46                                               );
  47
  48
  49
  50 struct compute_dialog
  51 {
  52   GladeXML *xml;  /* The xml that generated the widgets */
  53 };
  54
  55
  56 static void
  57 on_target_change (GObject *obj, const 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
  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
  88   /* Clear the syntax area textbuffer */
  89   gtk_text_buffer_get_start_iter (buffer, &start);
  90   gtk_text_buffer_get_end_iter (buffer, &end);
  91   gtk_text_buffer_delete (buffer, &start, &end);
  92
  93
  94   /* Unselect all items in the treeview */
  95   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (varlist));
  96   gtk_tree_selection_unselect_all (selection);
  97
  98   /* And the other one */
  99   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (funclist));
 100   gtk_tree_selection_unselect_all (selection);
 101 }
 102
 103
 104 static void
 105 erase_selection (GtkTextBuffer *buffer)
 106 {
 107   GtkTextIter start, end;
 108
 109   gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
 110
 111   gtk_text_buffer_delete (buffer, &start, &end);
 112 }
 113
 114
 115
 116 static void
 117 on_keypad_button (PsppireKeypad *kp, const gchar *syntax, gpointer data)
 118 {
 119   GladeXML *xml = data;
 120
 121   GtkWidget *rhs = get_widget_assert (xml, "compute-textview1");
 122
 123   GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (rhs));
 124
 125   erase_selection (buffer);
 126
 127   gtk_text_buffer_insert_at_cursor (buffer, syntax, strlen (syntax));
 128
 129   if (0 == strcmp (syntax, "()"))
 130     {
 131       GtkTextIter iter;
 132       GtkTextMark *cursor = gtk_text_buffer_get_insert (buffer);
 133       gtk_text_buffer_get_iter_at_mark (buffer, &iter, cursor);
 134       gtk_text_iter_backward_cursor_position (&iter);
 135       gtk_text_buffer_move_mark (buffer, cursor, &iter);
 136     }
 137
 138 }
 139
 140 static void
 141 erase (PsppireKeypad *kp, gpointer data)
 142 {
 143   GladeXML *xml = data;
 144
 145   GtkWidget *rhs = get_widget_assert (xml, "compute-textview1");
 146
 147   GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (rhs));
 148
 149   erase_selection (buffer);
 150 }
 151
 152 static char *
 153 generate_syntax (const struct compute_dialog *cd)
 154 {
 155   gchar *text;
 156   GString *string ;
 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
 161   GtkTextBuffer *buffer =
 162     gtk_text_view_get_buffer (GTK_TEXT_VIEW (syntax_area));
 163
 164   gtk_text_buffer_get_start_iter (buffer, &start);
 165   gtk_text_buffer_get_end_iter (buffer, &end);
 166
 167
 168   string = g_string_new ("COMPUTE ");
 169
 170   g_string_append (string, gtk_entry_get_text (GTK_ENTRY (target)));
 171
 172   g_string_append (string, " = ");
 173
 174   g_string_append (string,
 175                    gtk_text_buffer_get_text (buffer, &start, &end, FALSE));
 176
 177   g_string_append (string, ".");
 178
 179   text = string->str;
 180
 181   g_string_free (string, FALSE);
 182
 183   return text;
 184 }
 185
 186
 187 /* Pops up the Compute dialog box */
 188 void
 189 compute_dialog (GObject *o, gpointer data)
 190 {
 191   gint response;
 192   struct data_editor *de = data;
 193
 194   PsppireVarStore *vs;
 195   struct compute_dialog scd;
 196
 197   GladeXML *xml = XML_NEW ("psppire.glade");
 198
 199   GtkWidget *dialog = get_widget_assert   (xml, "compute-variable-dialog");
 200
 201   GtkWidget *dict_view = get_widget_assert   (xml, "compute-treeview1");
 202   GtkWidget *functions = get_widget_assert   (xml, "compute-treeview2");
 203   GtkWidget *keypad =    get_widget_assert   (xml, "psppire-keypad1");
 204   GtkWidget *target =    get_widget_assert   (xml, "compute-entry1");
 205   GtkWidget *syntax_area = get_widget_assert (xml, "compute-textview1");
 206   GtkWidget *var_selector = get_widget_assert (xml, "compute-selector1");
 207   GtkWidget *func_selector = get_widget_assert (xml, "compute-selector2");
 208
 209   GtkSheet *var_sheet =
 210     GTK_SHEET (get_widget_assert (de->xml, "variable_sheet"));
 211
 212   vs = PSPPIRE_VAR_STORE (gtk_sheet_get_model (var_sheet));
 213
 214
 215   gtk_window_set_transient_for (GTK_WINDOW (dialog), de->parent.window);
 216
 217
 218   attach_dictionary_to_treeview (GTK_TREE_VIEW (dict_view),
 219                                  vs->dict,
 220                                  GTK_SELECTION_SINGLE, NULL);
 221
 222
 223   psppire_selector_set_subjects (PSPPIRE_SELECTOR (var_selector),
 224                                  dict_view, syntax_area,
 225                                  insert_source_row_into_text_view,
 226                                  NULL);
 227
 228
 229   function_list_populate (GTK_TREE_VIEW (functions));
 230
 231   psppire_selector_set_subjects (PSPPIRE_SELECTOR (func_selector),
 232                                  functions, syntax_area,
 233                                  insert_function_into_syntax_area,
 234                                  NULL);
 235
 236
 237   scd.xml = xml;
 238
 239   g_signal_connect (target, "changed", G_CALLBACK (on_target_change), &scd);
 240
 241   g_signal_connect (dialog, "refresh", G_CALLBACK (refresh),  &scd);
 242
 243   g_signal_connect (keypad, "insert-syntax",
 244                     G_CALLBACK (on_keypad_button),  xml);
 245
 246   g_signal_connect (keypad, "erase",
 247                     G_CALLBACK (erase),  xml);
 248
 249
 250   response = psppire_dialog_run (PSPPIRE_DIALOG (dialog));
 251
 252
 253   switch (response)
 254     {
 255     case GTK_RESPONSE_OK:
 256       {
 257         gchar *syntax = generate_syntax (&scd);
 258         struct getl_interface *sss = create_syntax_string_source (syntax);
 259         execute_syntax (sss);
 260
 261         g_free (syntax);
 262       }
 263       break;
 264     case PSPPIRE_RESPONSE_PASTE:
 265       {
 266         gchar *syntax = generate_syntax (&scd);
 267
 268         struct syntax_editor *se =
 269           (struct syntax_editor *) window_create (WINDOW_SYNTAX, NULL);
 270
 271         gtk_text_buffer_insert_at_cursor (se->buffer, syntax, -1);
 272
 273         g_free (syntax);
 274       }
 275       break;
 276     default:
 277       break;
 278     }
 279
 280   g_object_unref (xml);
 281 }
 282
 283
 284 enum {
 285   COL_NAME,
 286   COL_USAGE,
 287   COL_ARITY
 288 };
 289
 290
 291 static void
 292 function_list_populate (GtkTreeView *tv)
 293 {
 294   GtkListStore *liststore;
 295   GtkTreeIter iter;
 296   gint i;
 297
 298   const gint n_funcs = expr_get_function_cnt ();
 299
 300   liststore = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
 301
 302   for (i = 0 ; i < n_funcs ; ++i)
 303     {
 304       const struct operation *op = expr_get_function (i);
 305
 306       gtk_list_store_append (liststore, &iter);
 307
 308       gtk_list_store_set (liststore, &iter,
 309                           COL_NAME, expr_operation_get_name (op),
 310                           COL_USAGE, expr_operation_get_prototype (op),
 311                           COL_ARITY, expr_operation_get_arg_cnt (op),
 312                           -1);
 313     }
 314
 315
 316
 317   /* Set the cell rendering */
 318
 319   {
 320     GtkTreeViewColumn *col;
 321     GtkCellRenderer *renderer;
 322
 323
 324     col = gtk_tree_view_column_new ();
 325
 326     gtk_tree_view_append_column (tv, col);
 327
 328     renderer = gtk_cell_renderer_text_new ();
 329
 330     gtk_tree_view_column_pack_start (col, renderer, TRUE);
 331
 332     gtk_tree_view_column_add_attribute (col, renderer, "text", COL_USAGE);
 333   }
 334
 335   gtk_tree_view_set_model (tv, GTK_TREE_MODEL (liststore));
 336 }
 337
 338
 339
 340
 341 static void
 342 insert_function_into_syntax_area (GtkTreeIter iter,
 343                                   GtkWidget *text_view,
 344                                   GtkTreeModel *model
 345                                   )
 346 {
 347   GString *string;
 348   GValue name_value = {0};
 349   GValue arity_value = {0};
 350   gint arity;
 351   gint i;
 352
 353   GtkTextBuffer *buffer ;
 354
 355   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
 356
 357   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
 358
 359   gtk_tree_model_get_value (model, &iter, COL_NAME, &name_value);
 360   gtk_tree_model_get_value (model, &iter, COL_ARITY, &arity_value);
 361
 362   arity = g_value_get_int (&arity_value);
 363
 364   string = g_string_new (g_value_get_string (&name_value));
 365
 366   g_string_append (string, "(");
 367   for ( i = 0 ; i < arity -1 ; ++i )
 368     {
 369       g_string_append (string, "?,");
 370     }
 371   g_string_append (string, "?)");
 372
 373
 374   erase_selection (buffer);
 375
 376   gtk_text_buffer_insert_at_cursor (buffer, string->str, string->len);
 377
 378   g_value_unset (&name_value);
 379   g_value_unset (&arity_value);
 380   g_string_free (string, TRUE);
 381
 382   /* Now position the cursor over the first '?' */
 383   {
 384     GtkTextIter insert;
 385     GtkTextIter selectbound;
 386     GtkTextMark *cursor = gtk_text_buffer_get_insert (buffer);
 387     gtk_text_buffer_get_iter_at_mark (buffer, &insert, cursor);
 388     for ( i = 0 ; i < arity ; ++i )
 389       {
 390         gtk_text_iter_backward_cursor_position (&insert);
 391         gtk_text_iter_backward_cursor_position (&insert);
 392       }
 393     selectbound = insert;
 394     gtk_text_iter_forward_cursor_position (&selectbound);
 395
 396     gtk_text_buffer_select_range (buffer, &insert, &selectbound);
 397   }
 398
 399 }
 400
 401 /* Inserts the name of the selected variable into the destination widget.
 402    The destination widget must be a GtkTextView
 403  */
 404 static void
 405 insert_source_row_into_text_view (GtkTreeIter iter,
 406                                   GtkWidget *dest,
 407                                   GtkTreeModel *model
 408                                   )
 409 {
 410   GtkTreePath *path;
 411   PsppireDict *dict;
 412   gint *idx;
 413   struct variable *var;
 414   GtkTreeIter dict_iter;
 415   gchar *name;
 416   GtkTextBuffer *buffer;
 417
 418   g_return_if_fail (GTK_IS_TEXT_VIEW (dest));
 419
 420   if ( GTK_IS_TREE_MODEL_FILTER (model))
 421     {
 422       dict = PSPPIRE_DICT (gtk_tree_model_filter_get_model
 423                            (GTK_TREE_MODEL_FILTER(model)));
 424
 425       gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER
 426                                                         (model),
 427                                                         &dict_iter, &iter);
 428     }
 429   else
 430     {
 431       dict = PSPPIRE_DICT (model);
 432       dict_iter = iter;
 433     }
 434
 435   path = gtk_tree_model_get_path (GTK_TREE_MODEL (dict), &dict_iter);
 436
 437   idx = gtk_tree_path_get_indices (path);
 438
 439   var =  psppire_dict_get_variable (dict, *idx);
 440
 441   gtk_tree_path_free (path);
 442
 443   name = pspp_locale_to_utf8 (var_get_name (var), -1, NULL);
 444
 445   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (dest));
 446
 447   erase_selection (buffer);
 448
 449   gtk_text_buffer_insert_at_cursor (buffer, name, -1);
 450
 451   g_free (name);
 452 }