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