Filter file choosers by mimetype instead of file name
[pspp-builds.git] / src / ui / gui / compute-dialog.c
1 /* PSPPIRE - a graphical user interface for PSPP.
2    Copyright (C) 2007, 2010, 2011  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 "psppire-data-window.h"
24 #include "psppire-var-store.h"
25 #include "psppire-selector.h"
26 #include "dialog-common.h"
27 #include <libpspp/i18n.h>
28
29 #include <language/expressions/public.h>
30 #include "executor.h"
31
32 static void function_list_populate (GtkTreeView *tv);
33
34 static void insert_function_into_syntax_area (GtkTreeIter iter,
35                                               GtkWidget *text_view,
36                                               GtkTreeModel *model,
37                                               gpointer data
38                                               );
39
40 static void insert_source_row_into_text_view (GtkTreeIter iter,
41                                               GtkWidget *dest,
42                                               GtkTreeModel *model,
43                                               gpointer data
44                                               );
45
46
47
48 struct compute_dialog
49 {
50   GtkBuilder *xml;  /* The xml that generated the widgets */
51   PsppireDict *dict;
52   gboolean use_type;
53 };
54
55
56 static void
57 on_target_change (GObject *obj, 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   /* Clear the target variable entry box */
83   gtk_entry_set_text (GTK_ENTRY (target), "");
84   g_signal_emit_by_name (target, "changed");
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   /* 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   GtkBuilder *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   GtkBuilder *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   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 ( cd-> use_type &&
181        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.\n",
204                           target_name,
205                           expression
206                           );
207
208   g_string_append (string, "EXECUTE.\n");
209
210
211   g_free (expression);
212
213   text = string->str;
214
215   g_string_free (string, FALSE);
216
217   return text;
218 }
219
220 static void
221 reset_type_label_dialog (struct compute_dialog *cd)
222 {
223   const gchar *target_name;
224   struct variable *target_var;
225
226   GtkWidget *width_entry =
227     get_widget_assert (cd->xml, "type-and-label-width");
228
229   GtkWidget *label_entry =
230     get_widget_assert (cd->xml, "type-and-label-label-entry");
231
232   GtkWidget *numeric_target =
233     get_widget_assert (cd->xml, "radio-button-numeric");
234
235   GtkWidget *string_target =
236     get_widget_assert (cd->xml, "radio-button-string");
237
238
239   target_name = gtk_entry_get_text
240     (GTK_ENTRY (get_widget_assert (cd->xml, "compute-entry1")));
241
242
243   if ( (target_var = psppire_dict_lookup_var (cd->dict, target_name)) )
244     {
245       /* Existing Variable */
246       const gchar *label ;
247       GtkWidget *user_label =
248         get_widget_assert (cd->xml, "radio-button-user-label");
249
250       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (user_label), TRUE);
251
252       label = var_get_label (target_var);
253
254       if ( label )
255         {
256           gtk_entry_set_text (GTK_ENTRY (label_entry), label);
257         }
258
259       gtk_widget_set_sensitive (width_entry, FALSE);
260
261       if ( var_is_numeric (target_var))
262         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (numeric_target),
263                                       TRUE);
264       else
265         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (string_target),
266                                       TRUE);
267
268       gtk_widget_set_sensitive (numeric_target, FALSE);
269       gtk_widget_set_sensitive (string_target, FALSE);
270     }
271   else
272     {
273       GtkWidget *expression =
274         get_widget_assert (cd->xml, "radio-button-expression-label");
275
276       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (expression), TRUE);
277
278       gtk_widget_set_sensitive (width_entry, TRUE);
279       gtk_widget_set_sensitive (numeric_target, TRUE);
280       gtk_widget_set_sensitive (string_target, TRUE);
281
282       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (numeric_target),
283                                     TRUE);
284     }
285
286 }
287
288 static void
289 run_type_label_dialog (GtkButton *b, gpointer data)
290 {
291   struct compute_dialog *cd = data;
292   gint response;
293
294   GtkWidget *subdialog = get_widget_assert (cd->xml, "type-and-label-dialog");
295   GtkWidget *dialog = get_widget_assert (cd->xml, "compute-variable-dialog");
296
297   gtk_window_set_transient_for (GTK_WINDOW (subdialog), GTK_WINDOW (dialog));
298
299   reset_type_label_dialog (cd);
300   response = psppire_dialog_run (PSPPIRE_DIALOG (subdialog));
301   if ( response == PSPPIRE_RESPONSE_CONTINUE)
302     cd->use_type = TRUE;
303 }
304
305
306 static void
307 on_expression_toggle (GtkToggleButton *button, gpointer data)
308 {
309   struct compute_dialog *cd = data;
310
311   GtkWidget *entry =
312     get_widget_assert (cd->xml, "type-and-label-label-entry");
313
314   if ( gtk_toggle_button_get_active (button))
315     {
316       gtk_entry_set_text (GTK_ENTRY (entry), "");
317       gtk_widget_set_sensitive (entry, FALSE);
318     }
319   else
320     {
321       const char *label;
322       struct variable *target_var;
323       const gchar *target_name = gtk_entry_get_text
324         (GTK_ENTRY (get_widget_assert (cd->xml, "compute-entry1")));
325
326       target_var = psppire_dict_lookup_var (cd->dict, target_name);
327       if ( target_var )
328         {
329           label = var_get_label (target_var);
330
331           if ( label )
332             gtk_entry_set_text (GTK_ENTRY (entry), label);
333         }
334       else
335         gtk_entry_set_text (GTK_ENTRY (entry), "");
336
337       gtk_widget_set_sensitive (entry, TRUE);
338     }
339 }
340
341
342 /* Return TRUE if the dialog box's widgets' state are such that clicking OK
343    might not result in erroneous syntax being generated */
344 static gboolean
345 contents_plausible (gpointer data)
346 {
347   struct compute_dialog *cd = data;
348
349   GtkWidget *target      = get_widget_assert (cd->xml, "compute-entry1");
350   GtkWidget *syntax_area = get_widget_assert (cd->xml, "compute-textview1");
351   GtkTextBuffer *buffer  =
352     gtk_text_view_get_buffer (GTK_TEXT_VIEW (syntax_area));
353
354   if ( 0 == strcmp ("", gtk_entry_get_text (GTK_ENTRY (target))))
355     return FALSE;
356
357   if ( gtk_text_buffer_get_char_count (buffer) == 0 )
358     return FALSE;
359
360   return TRUE;
361 }
362
363 /* Pops up the Compute dialog box */
364 void
365 compute_dialog (PsppireDataWindow *de)
366 {
367   gint response;
368
369   PsppireVarStore *vs = NULL;
370   struct compute_dialog scd;
371
372   GtkBuilder *xml = builder_new ("compute.ui");
373
374   GtkWidget *dialog = get_widget_assert   (xml, "compute-variable-dialog");
375
376   GtkWidget *dict_view = get_widget_assert (xml, "compute-treeview1");
377   GtkWidget *functions = get_widget_assert (xml, "compute-treeview2");
378   GtkWidget *keypad    = get_widget_assert (xml, "psppire-keypad1");
379   GtkWidget *target    = get_widget_assert (xml, "compute-entry1");
380   GtkWidget *var_selector = get_widget_assert (xml, "compute-selector1");
381   GtkWidget *func_selector = get_widget_assert (xml, "compute-selector2");
382   GtkWidget *type_and_label = get_widget_assert (xml, "compute-button1");
383
384   GtkWidget *expression =
385         get_widget_assert (xml, "radio-button-expression-label");
386
387
388   g_object_get (de->data_editor, "var-store", &vs, NULL);
389   g_object_get (vs, "dictionary", &scd.dict, NULL);
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), GTK_WINDOW (de));
396
397   
398   g_object_set (dict_view, "model", scd.dict,
399                 "selection-mode", GTK_SELECTION_SINGLE,
400                 NULL);
401
402   psppire_selector_set_select_func (PSPPIRE_SELECTOR (var_selector),
403                                     insert_source_row_into_text_view, NULL);
404
405   function_list_populate (GTK_TREE_VIEW (functions));
406
407   psppire_selector_set_select_func (PSPPIRE_SELECTOR (func_selector),
408                                     insert_function_into_syntax_area, NULL);
409
410   scd.xml = xml;
411
412   psppire_dialog_set_valid_predicate (PSPPIRE_DIALOG (dialog),
413                                       contents_plausible, &scd);
414
415   g_signal_connect (target, "changed", G_CALLBACK (on_target_change), &scd);
416
417   g_signal_connect (dialog, "refresh", G_CALLBACK (refresh),  &scd);
418
419   g_signal_connect (keypad, "insert-syntax",
420                     G_CALLBACK (on_keypad_button),  xml);
421
422   g_signal_connect (keypad, "erase",
423                     G_CALLBACK (erase),  xml);
424
425
426   g_signal_connect (type_and_label, "clicked",
427                     G_CALLBACK (run_type_label_dialog),  &scd);
428
429
430
431   response = psppire_dialog_run (PSPPIRE_DIALOG (dialog));
432
433
434   switch (response)
435     {
436     case GTK_RESPONSE_OK:
437       g_free (execute_syntax_string (de, generate_syntax (&scd)));
438       break;
439     case PSPPIRE_RESPONSE_PASTE:
440       g_free (paste_syntax_to_window (generate_syntax (&scd)));
441       break;
442     default:
443       break;
444     }
445
446   g_object_unref (xml);
447 }
448
449
450 enum {
451   COMPUTE_COL_NAME,
452   COMPUTE_COL_USAGE,
453   COMPUTE_COL_ARITY
454 };
455
456
457 static void
458 function_list_populate (GtkTreeView *tv)
459 {
460   GtkListStore *liststore;
461   GtkTreeIter iter;
462   gint i;
463
464   const gint n_funcs = expr_get_function_cnt ();
465
466   liststore = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
467
468   for (i = 0 ; i < n_funcs ; ++i)
469     {
470       const struct operation *op = expr_get_function (i);
471
472       gtk_list_store_append (liststore, &iter);
473
474       gtk_list_store_set (liststore, &iter,
475                           COMPUTE_COL_NAME, expr_operation_get_name (op),
476                           COMPUTE_COL_USAGE, expr_operation_get_prototype (op),
477                           COMPUTE_COL_ARITY, expr_operation_get_arg_cnt (op),
478                           -1);
479     }
480
481
482
483   /* Set the cell rendering */
484
485   {
486     GtkTreeViewColumn *col;
487     GtkCellRenderer *renderer;
488
489
490     col = gtk_tree_view_column_new ();
491
492     gtk_tree_view_append_column (tv, col);
493
494     renderer = gtk_cell_renderer_text_new ();
495
496     gtk_tree_view_column_pack_start (col, renderer, TRUE);
497
498     gtk_tree_view_column_add_attribute (col, renderer, "text", COMPUTE_COL_USAGE);
499   }
500
501   gtk_tree_view_set_model (tv, GTK_TREE_MODEL (liststore));
502 }
503
504
505
506
507 static void
508 insert_function_into_syntax_area (GtkTreeIter iter,
509                                   GtkWidget *text_view,
510                                   GtkTreeModel *model,
511                                   gpointer data
512                                   )
513 {
514   GString *string;
515   GValue name_value = {0};
516   GValue arity_value = {0};
517   gint arity;
518   gint i;
519
520   GtkTextBuffer *buffer ;
521
522   g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
523
524   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
525
526   gtk_tree_model_get_value (model, &iter, COMPUTE_COL_NAME, &name_value);
527   gtk_tree_model_get_value (model, &iter, COMPUTE_COL_ARITY, &arity_value);
528
529   arity = g_value_get_int (&arity_value);
530
531   string = g_string_new (g_value_get_string (&name_value));
532
533   g_string_append (string, "(");
534   for ( i = 0 ; i < arity -1 ; ++i )
535     {
536       g_string_append (string, "?,");
537     }
538   g_string_append (string, "?)");
539
540
541   erase_selection (buffer);
542
543   gtk_text_buffer_insert_at_cursor (buffer, string->str, string->len);
544
545   g_value_unset (&name_value);
546   g_value_unset (&arity_value);
547   g_string_free (string, TRUE);
548
549   /* Now position the cursor over the first '?' */
550   {
551     GtkTextIter insert;
552     GtkTextIter selectbound;
553     GtkTextMark *cursor = gtk_text_buffer_get_insert (buffer);
554     gtk_text_buffer_get_iter_at_mark (buffer, &insert, cursor);
555     for ( i = 0 ; i < arity ; ++i )
556       {
557         gtk_text_iter_backward_cursor_position (&insert);
558         gtk_text_iter_backward_cursor_position (&insert);
559       }
560     selectbound = insert;
561     gtk_text_iter_forward_cursor_position (&selectbound);
562
563     gtk_text_buffer_select_range (buffer, &insert, &selectbound);
564   }
565
566 }
567
568 /* Inserts the name of the selected variable into the destination widget.
569    The destination widget must be a GtkTextView
570  */
571 static void
572 insert_source_row_into_text_view (GtkTreeIter iter,
573                                   GtkWidget *dest,
574                                   GtkTreeModel *model,
575                                   gpointer data
576                                   )
577 {
578   GtkTreePath *path;
579   PsppireDict *dict;
580   gint *idx;
581   struct variable *var;
582   GtkTreeIter dict_iter;
583   GtkTextBuffer *buffer;
584
585   g_return_if_fail (GTK_IS_TEXT_VIEW (dest));
586
587   if ( GTK_IS_TREE_MODEL_FILTER (model))
588     {
589       dict = PSPPIRE_DICT (gtk_tree_model_filter_get_model
590                            (GTK_TREE_MODEL_FILTER(model)));
591
592       gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER
593                                                         (model),
594                                                         &dict_iter, &iter);
595     }
596   else
597     {
598       dict = PSPPIRE_DICT (model);
599       dict_iter = iter;
600     }
601
602   path = gtk_tree_model_get_path (GTK_TREE_MODEL (dict), &dict_iter);
603
604   idx = gtk_tree_path_get_indices (path);
605
606   var =  psppire_dict_get_variable (dict, *idx);
607
608   gtk_tree_path_free (path);
609
610   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (dest));
611
612   erase_selection (buffer);
613
614   gtk_text_buffer_insert_at_cursor (buffer, var_get_name (var), -1);
615
616 }