Categoricals.c Create entries for all groups.
[pspp] / src / ui / gui / find-dialog.c
1 /* PSPPIRE - a graphical user interface for PSPP.
2    Copyright (C) 2007, 2009  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 /* This module implements the "Find" dialog; a dialog box to locate cases
19 which match particular strings */
20
21 #include <config.h>
22
23 #include "find-dialog.h"
24 #include "psppire-selector.h"
25 #include "psppire-dialog.h"
26 #include "helper.h"
27 #include "psppire-data-window.h"
28 #include "dict-display.h"
29 #include <data/value.h>
30 #include <data/format.h>
31 #include <data/datasheet.h>
32 #include <data/data-in.h>
33 #include "psppire-data-store.h"
34 #include <ctype.h>
35 #include <sys/types.h>
36 #include <regex.h>
37 #include <libpspp/cast.h>
38 #include <libpspp/message.h>
39
40 #include <gtk/gtk.h>
41 #include <stdlib.h>
42
43 #include "xalloc.h"
44
45 #include <gettext.h>
46 #define _(msgid) gettext (msgid)
47 #define N_(msgid) msgid
48
49
50 /* FIXME: These shouldn't be here */
51 #include "psppire-var-store.h"
52
53 struct find_dialog
54 {
55   GtkBuilder *xml;
56   PsppireDict *dict;
57   struct datasheet *data;
58   PsppireDataWindow *de;
59   GtkWidget *variable_entry;
60   GtkWidget *value_entry;
61   GtkWidget *value_labels_checkbox;
62   GtkWidget *match_regexp_checkbox;
63   GtkWidget *match_substring_checkbox;
64 };
65
66 static void
67 find_value (const struct find_dialog *fd, casenumber current_row,
68            casenumber *row, int *column);
69
70
71 /* A callback which occurs whenever the "Refresh" button is clicked,
72    and when the dialog pops up.
73    It restores the dialog to its default state.
74 */
75 static void
76 refresh (GObject *obj, const struct find_dialog *fd)
77 {
78   gtk_toggle_button_set_active
79     (GTK_TOGGLE_BUTTON (get_widget_assert (fd->xml, "find-wrap")),
80      FALSE);
81
82   gtk_toggle_button_set_active
83     (GTK_TOGGLE_BUTTON (get_widget_assert (fd->xml, "find-backwards")),
84      FALSE);
85
86   gtk_entry_set_text (GTK_ENTRY (fd->variable_entry), "");
87   gtk_entry_set_text (GTK_ENTRY (fd->value_entry), "");
88
89   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fd->match_regexp_checkbox),
90                                 FALSE);
91
92   gtk_toggle_button_set_active
93     (GTK_TOGGLE_BUTTON (fd->match_substring_checkbox), FALSE);
94
95
96   gtk_toggle_button_set_active
97     (GTK_TOGGLE_BUTTON (fd->match_substring_checkbox), FALSE);
98 }
99
100 /* Callback on the "Find" button */
101 static void
102 do_find (GObject *obj, const struct find_dialog *fd)
103 {
104   casenumber x = -1;
105   gint column = -1;
106   glong row;
107
108   g_object_get (fd->de->data_editor, "current-case", &row, NULL);
109
110   if ( row < 0 )
111     row = 0;
112
113   find_value (fd, row, &x, &column);
114
115
116   if ( x != -1)
117     {
118       gtk_notebook_set_current_page (GTK_NOTEBOOK (fd->de->data_editor),
119                                      PSPPIRE_DATA_EDITOR_DATA_VIEW);
120
121       g_object_set (fd->de->data_editor,
122                     "current-case", x,
123                     "current-variable", column,
124                     NULL);
125     }
126
127 }
128
129 /* Callback on the selector.
130    It gets invoked whenever a variable is selected */
131 static void
132 on_select (GtkEntry *entry, gpointer data)
133 {
134   struct find_dialog *fd = data;
135   const char *var_name = gtk_entry_get_text (GTK_ENTRY (fd->variable_entry));
136   struct variable *var = dict_lookup_var (fd->dict->dict, var_name);
137   gboolean search_labels ;
138
139   g_return_if_fail (var);
140
141   gtk_widget_set_sensitive (fd->value_labels_checkbox,
142                             var_has_value_labels (var));
143
144   search_labels =
145     gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (fd->value_labels_checkbox));
146
147   gtk_widget_set_sensitive (fd->match_regexp_checkbox,
148                             var_is_alpha (var) || search_labels);
149
150
151   gtk_widget_set_sensitive (fd->match_substring_checkbox,
152                             var_is_alpha (var) || search_labels);
153 }
154
155 /* Callback on the selector.
156    It gets invoked whenever a variable is unselected */
157 static void
158 on_deselect (GtkEntry *entry, gpointer data)
159 {
160   struct find_dialog *fd = data;
161
162   gtk_widget_set_sensitive (fd->value_labels_checkbox, FALSE);
163   gtk_widget_set_sensitive (fd->match_substring_checkbox, FALSE);
164   gtk_widget_set_sensitive (fd->match_regexp_checkbox, FALSE);
165 }
166
167 static void
168 value_labels_toggled (GtkToggleButton *tb, gpointer data)
169 {
170   struct find_dialog *fd = data;
171
172   const char *var_name = gtk_entry_get_text (GTK_ENTRY (fd->variable_entry));
173   const struct variable *var = dict_lookup_var (fd->dict->dict, var_name);
174
175   gboolean active = gtk_toggle_button_get_active  (tb) ;
176
177   gtk_widget_set_sensitive (fd->match_substring_checkbox,
178                             active || (var && var_is_alpha (var)));
179
180   gtk_widget_set_sensitive (fd->match_regexp_checkbox,
181                               active || (var && var_is_alpha (var)));
182 }
183
184 /* Pops up the Find dialog box
185  */
186 void
187 find_dialog (PsppireDataWindow *de)
188 {
189   struct find_dialog fd;
190
191   GtkWidget *dialog ;
192   GtkWidget *source ;
193   GtkWidget *selector;
194   GtkWidget *find_button;
195
196   GtkWidget *buttonbox;
197
198   PsppireVarStore *vs ;
199   PsppireDataStore *ds ;
200
201   fd.xml = builder_new ("find.ui");
202   fd.de = de;
203
204   find_button = gtk_button_new_from_stock  (GTK_STOCK_FIND);
205   gtk_widget_show (find_button);
206
207   buttonbox = get_widget_assert (fd.xml, "find-buttonbox");
208
209   psppire_box_pack_start_defaults (GTK_BOX (buttonbox), find_button);
210   gtk_box_reorder_child (GTK_BOX (buttonbox), find_button, 0);
211
212   dialog = get_widget_assert (fd.xml, "find-dialog");
213   source = get_widget_assert (fd.xml, "find-variable-treeview");
214   selector = get_widget_assert (fd.xml, "find-selector");
215
216   g_object_get (de->data_editor,
217                 "var-store", &vs,
218                 "data-store", &ds,
219                 NULL);
220
221   g_object_get (vs, "dictionary", &fd.dict, NULL);
222
223   fd.data = ds->datasheet;
224
225   fd.variable_entry        = get_widget_assert (fd.xml, "find-variable-entry");
226   fd.value_entry           = get_widget_assert (fd.xml, "find-value-entry");
227   fd.value_labels_checkbox =
228     get_widget_assert (fd.xml,
229                        "find-value-labels-checkbutton");
230
231   fd.match_regexp_checkbox =
232     get_widget_assert (fd.xml,
233                        "find-match-regexp-checkbutton");
234
235   fd.match_substring_checkbox =
236     get_widget_assert (fd.xml,
237                        "find-match-substring-checkbutton");
238
239
240
241   gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
242
243
244   g_object_set (source, "model", fd.dict,
245         "selection-mode", GTK_SELECTION_SINGLE,
246         NULL);
247
248
249   psppire_selector_set_filter_func (PSPPIRE_SELECTOR (selector),
250                                     is_currently_in_entry);
251
252   g_signal_connect (dialog, "refresh", G_CALLBACK (refresh),  &fd);
253
254   g_signal_connect (find_button, "clicked", G_CALLBACK (do_find),  &fd);
255
256   g_signal_connect (selector, "selected",
257                     G_CALLBACK (on_select),  &fd);
258
259   g_signal_connect (selector, "de-selected",
260                     G_CALLBACK (on_deselect),  &fd);
261
262   g_signal_connect (fd.value_labels_checkbox, "toggled",
263                     G_CALLBACK (value_labels_toggled),  &fd);
264
265
266   psppire_dialog_run (PSPPIRE_DIALOG (dialog));
267
268   g_object_unref (fd.xml);
269 }
270
271 \f
272 /* Iterators */
273
274 static void
275 forward (casenumber *i, struct datasheet *data UNUSED)
276 {
277   ++*i;
278 }
279
280
281 static void
282 forward_wrap (casenumber *i, struct datasheet *data)
283 {
284   if ( ++*i >=  datasheet_get_n_rows (data) ) *i = 0;
285 }
286
287 static void
288 backward (casenumber *i, struct datasheet *data UNUSED)
289 {
290   --*i;
291 }
292
293
294 static void
295 backward_wrap (casenumber *i, struct datasheet *data)
296 {
297   if ( --*i < 0 )
298     *i = datasheet_get_n_rows (data) - 1;
299 }
300
301
302 /* Current plus one */
303 static casenumber
304 cp1 (casenumber current, struct datasheet *data)
305 {
306   return current + 1;
307 }
308
309 /* Current plus one, circular */
310 static casenumber
311 cp1c (casenumber current, struct datasheet *data)
312 {
313   casenumber next = current;
314
315   forward_wrap (&next, data);
316
317   return next;
318 }
319
320
321 /* Current minus one */
322 static casenumber
323 cm1 (casenumber current, struct datasheet *data)
324 {
325   return current - 1;
326 }
327
328 /* Current minus one, circular */
329 static casenumber
330 cm1c (casenumber current, struct datasheet *data)
331 {
332   casenumber next = current;
333
334   backward_wrap (&next, data);
335
336   return next;
337 }
338
339
340 static casenumber
341 last (casenumber current, struct datasheet *data)
342 {
343   return datasheet_get_n_rows (data) ;
344 }
345
346 static casenumber
347 minus1 (casenumber current, struct datasheet *data)
348 {
349   return -1;
350 }
351
352 /* An type to facilitate iterating through casenumbers */
353 struct casenum_iterator
354 {
355   /* returns the first case to access */
356   casenumber (*start) (casenumber, struct datasheet *);
357
358   /* Returns one past the last case to access */
359   casenumber (*end) (casenumber, struct datasheet *);
360
361   /* Sets the first arg to the next case to access */
362   void (*next) (casenumber *, struct datasheet *);
363 };
364
365 enum iteration_type{
366   FORWARD = 0,
367   FORWARD_WRAP,
368   REVERSE,
369   REVERSE_WRAP,
370   n_iterators
371 };
372
373 static const struct casenum_iterator ip[n_iterators] =
374   {
375     {cp1, last, forward},
376     {cp1c, cm1, forward_wrap},
377     {cm1, minus1, backward},
378     {cm1c, cp1, backward_wrap}
379   };
380
381
382 \f
383 /* A factory returning an iterator according to the dialog box's settings */
384 static const struct casenum_iterator *
385 get_iteration_params (const struct find_dialog *fd)
386 {
387   gboolean wrap = gtk_toggle_button_get_active
388     (GTK_TOGGLE_BUTTON (get_widget_assert (fd->xml, "find-wrap")));
389
390   gboolean reverse = gtk_toggle_button_get_active
391     (GTK_TOGGLE_BUTTON (get_widget_assert (fd->xml, "find-backwards")));
392
393   if ( wrap )
394     {
395       if ( reverse )
396         return &ip[REVERSE_WRAP];
397       else
398         return &ip[FORWARD_WRAP];
399     }
400   else
401     {
402       if ( reverse )
403         return &ip[REVERSE];
404       else
405         return &ip[FORWARD];
406     }
407 }
408
409
410 enum string_cmp_flags
411   {
412     STR_CMP_SUBSTR = 0x01, /* Find strings which are substrings of the
413                               values */
414     STR_CMP_REGEXP = 0x02, /* Match against a regular expression */
415
416     STR_CMP_LABELS = 0x04  /* Match against the values' labels instead
417                               of the data */
418   };
419
420
421 /* An abstract base type for comparing union values against a reference */
422 struct comparator
423 {
424   const struct variable *var;
425   enum string_cmp_flags flags;
426   const PsppireDict *dict;
427
428   bool (*compare) (const struct comparator *,
429                    const union value *);
430
431   void (*destroy) (struct comparator *);
432 };
433
434
435 /* A comparator which operates on the unadulterated union values */
436 struct value_comparator
437 {
438   struct comparator parent;
439   union value pattern;
440 };
441
442 /* A comparator which matches string values or parts thereof */
443 struct string_comparator
444 {
445   struct comparator parent;
446   const char *pattern;
447 };
448
449 /* A comparator to match string values against a POSIX.2 regular expression */
450 struct regexp_comparator
451 {
452   struct comparator parent;
453   regex_t re;
454 };
455
456
457 static bool
458 value_compare (const struct comparator *cmptr,
459                const union value *v)
460 {
461   const struct value_comparator *vc = (const struct value_comparator *) cmptr;
462   return 0 == value_compare_3way (v, &vc->pattern, var_get_width (cmptr->var));
463 }
464
465
466 /* Return true if the label of VAL matches the reference string*/
467 static bool
468 string_label_compare (const struct comparator *cmptr,
469                 const union value *val)
470 {
471   const struct string_comparator *ssc =
472     (const struct string_comparator *) cmptr;
473
474   const char *text = var_lookup_value_label (cmptr->var, val);
475   int width = strlen (text);
476
477   assert ( cmptr->flags & STR_CMP_LABELS);
478
479   g_return_val_if_fail (width > 0, false);
480
481   if ( cmptr->flags & STR_CMP_SUBSTR)
482     return (NULL != g_strstr_len (text, width, ssc->pattern));
483   else
484     return (0 == strncmp (text, ssc->pattern, width));
485 }
486
487 /* Return true if VAL matches the reference string*/
488 static bool
489 string_value_compare (const struct comparator *cmptr,
490                       const union value *val)
491 {
492   bool found;
493   char *text;
494   const struct string_comparator *ssc =
495     (const struct string_comparator *) cmptr;
496
497   int width = var_get_width (cmptr->var);
498   g_return_val_if_fail (width > 0, false);
499   assert ( ! (cmptr->flags & STR_CMP_LABELS));
500
501   text = value_to_text (*val, cmptr->dict, *var_get_write_format (cmptr->var));
502
503   if ( cmptr->flags & STR_CMP_SUBSTR)
504     found =  (NULL != g_strstr_len (text, width, ssc->pattern));
505   else
506     found = (0 == strncmp (text, ssc->pattern, width));
507
508   free (text);
509   return found;
510 }
511
512
513
514 /* Return true if VAL matched the regexp */
515 static bool
516 regexp_value_compare (const struct comparator *cmptr,
517                 const union value *val)
518 {
519   char *text;
520   bool retval;
521   const struct regexp_comparator *rec =
522     (const struct regexp_comparator *) cmptr;
523
524   int width = var_get_width (cmptr->var);
525
526   assert  ( ! (cmptr->flags & STR_CMP_LABELS) );
527
528   g_return_val_if_fail (width > 0, false);
529
530   text = value_to_text (*val, cmptr->dict, *var_get_write_format (cmptr->var));
531   /* We must remove trailing whitespace, otherwise $ will not match where
532      one would expect */
533   g_strchomp (text);
534
535   retval = (0 == regexec (&rec->re, text, 0, 0, 0));
536
537   g_free (text);
538
539   return retval;
540 }
541
542 /* Return true if the label of VAL matched the regexp */
543 static bool
544 regexp_label_compare (const struct comparator *cmptr,
545                       const union value *val)
546 {
547   const char *text;
548   const struct regexp_comparator *rec =
549     (const struct regexp_comparator *) cmptr;
550
551   int width ;
552
553   assert ( cmptr->flags & STR_CMP_LABELS);
554
555   text = var_lookup_value_label (cmptr->var, val);
556   width = strlen (text);
557
558   g_return_val_if_fail (width > 0, false);
559
560   return (0 == regexec (&rec->re, text, 0, 0, 0));
561 }
562
563
564
565 static void
566 regexp_destroy (struct comparator *cmptr)
567 {
568   struct regexp_comparator *rec
569     = UP_CAST (cmptr, struct regexp_comparator, parent);
570
571   regfree (&rec->re);
572 }
573
574 static void
575 cmptr_value_destroy (struct comparator *cmptr)
576 {
577   struct value_comparator *vc
578     = UP_CAST (cmptr, struct value_comparator, parent);
579   value_destroy (&vc->pattern, var_get_width (cmptr->var));
580 }
581
582
583 static struct comparator *
584 value_comparator_create (const struct variable *var, const PsppireDict *dict, const char *target)
585 {
586   struct value_comparator *vc = xzalloc (sizeof (*vc));
587   struct comparator *cmptr = &vc->parent;
588
589   cmptr->flags = 0;
590   cmptr->var = var;
591   cmptr->compare  = value_compare ;
592   cmptr->destroy = cmptr_value_destroy;
593   cmptr->dict = dict;
594
595   text_to_value (target, dict, var, &vc->pattern);
596
597   return cmptr;
598 }
599
600 static struct comparator *
601 string_comparator_create (const struct variable *var, const PsppireDict *dict, 
602                           const char *target,
603                           enum string_cmp_flags flags)
604 {
605   struct string_comparator *ssc = xzalloc (sizeof (*ssc));
606   struct comparator *cmptr = &ssc->parent;
607
608   cmptr->flags = flags;
609   cmptr->var = var;
610   cmptr->dict = dict;
611
612   if ( flags & STR_CMP_LABELS)
613     cmptr->compare = string_label_compare;
614   else
615     cmptr->compare = string_value_compare;
616
617   ssc->pattern = target;
618
619   return cmptr;
620 }
621
622
623 static struct comparator *
624 regexp_comparator_create (const struct variable *var, const PsppireDict *dict, const char *target,
625                           enum string_cmp_flags flags)
626 {
627   int code;
628   struct regexp_comparator *rec = xzalloc (sizeof (*rec));
629   struct comparator *cmptr = &rec->parent;
630
631   cmptr->flags = flags;
632   cmptr->var = var;
633   cmptr->dict = dict;
634   cmptr->compare  = (flags & STR_CMP_LABELS)
635     ? regexp_label_compare : regexp_value_compare ;
636
637   cmptr->destroy  = regexp_destroy;
638
639   code = regcomp (&rec->re, target, 0);
640   if ( code != 0 )
641     {
642       char *errbuf = NULL;
643       size_t errbuf_size = regerror (code, &rec->re, errbuf,  0);
644
645       errbuf = xmalloc (errbuf_size);
646
647       regerror (code, &rec->re, errbuf, errbuf_size);
648
649       msg (ME, _("Bad regular expression: %s"), errbuf);
650
651       free ( cmptr);
652       free (errbuf);
653       return NULL;
654     }
655
656   return cmptr;
657 }
658
659
660 /* Compare V against CMPTR's reference */
661 static bool
662 comparator_compare (const struct comparator *cmptr,
663                     const union value *v)
664 {
665   return cmptr->compare (cmptr, v);
666 }
667
668 /* Destroy CMPTR */
669 static void
670 comparator_destroy (struct comparator *cmptr)
671 {
672   if ( ! cmptr )
673     return ;
674
675   if ( cmptr->destroy )
676     cmptr->destroy (cmptr);
677
678   free (cmptr);
679 }
680
681
682 static struct comparator *
683 comparator_factory (const struct variable *var, const PsppireDict *dict, const char *str,
684                     enum string_cmp_flags flags)
685 {
686   if ( flags & STR_CMP_REGEXP )
687     return regexp_comparator_create (var, dict, str, flags);
688
689   if ( flags & (STR_CMP_SUBSTR | STR_CMP_LABELS) )
690     return string_comparator_create (var, dict, str, flags);
691
692   return value_comparator_create (var, dict, str);
693 }
694
695
696 /* Find the row and column specified by the dialog FD, starting at CURRENT_ROW.
697    After the function returns, *ROW contains the row and *COLUMN the column.
698    If no such case is found, then *ROW will be set to -1
699  */
700 static void
701 find_value (const struct find_dialog *fd, casenumber current_row,
702            casenumber *row, int *column)
703 {
704   int width;
705   const struct variable *var;
706   const char *var_name = gtk_entry_get_text (GTK_ENTRY (fd->variable_entry));
707   const char *target_string = gtk_entry_get_text (GTK_ENTRY (fd->value_entry));
708
709   enum string_cmp_flags flags = 0;
710   g_assert (current_row >= 0);
711
712   var = dict_lookup_var (fd->dict->dict, var_name);
713   if ( ! var )
714     return ;
715
716   width = var_get_width (var);
717
718   *column = var_get_dict_index (var);
719   *row = -1;
720
721   if ( gtk_toggle_button_get_active
722        (GTK_TOGGLE_BUTTON (fd->match_substring_checkbox)))
723     flags |= STR_CMP_SUBSTR;
724
725   if ( gtk_toggle_button_get_active
726        (GTK_TOGGLE_BUTTON (fd->match_regexp_checkbox)))
727     flags |= STR_CMP_REGEXP;
728
729   if ( gtk_toggle_button_get_active
730        (GTK_TOGGLE_BUTTON (fd->value_labels_checkbox)))
731     flags |= STR_CMP_LABELS;
732
733   {
734     union value val;
735     casenumber i;
736     const struct casenum_iterator *ip = get_iteration_params (fd);
737     struct comparator *cmptr =
738       comparator_factory (var, fd->dict, target_string, flags);
739
740     value_init (&val, width);
741     if ( ! cmptr)
742       goto finish;
743
744     for (i = ip->start (current_row, fd->data);
745          i != ip->end (current_row, fd->data);
746          ip->next (&i, fd->data))
747       {
748         datasheet_get_value (fd->data, i, var_get_case_index (var), &val);
749
750         if ( comparator_compare (cmptr, &val))
751           {
752             *row = i;
753             break;
754           }
755       }
756
757   finish:
758     comparator_destroy (cmptr);
759     value_destroy (&val, width);
760   }
761 }