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