store intercept in proper place when using QR method
[pspp-builds.git] / src / ui / gui / find-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
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 "data-editor.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 <glade/glade.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   GladeXML *xml;
56   PsppireDict *dict;
57   struct datasheet *data;
58   struct data_editor *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 (GObject *o, gpointer data)
188 {
189   struct data_editor *de = data;
190
191   struct find_dialog fd;
192
193   GtkWidget *dialog ;
194   GtkWidget *source ;
195   GtkWidget *selector;
196   GtkWidget *find_button;
197
198   GtkWidget *buttonbox;
199
200   PsppireVarStore *vs ;
201   PsppireDataStore *ds ;
202
203   fd.xml = XML_NEW ("psppire.glade");
204   fd.de = de;
205
206   find_button = gtk_button_new_from_stock  (GTK_STOCK_FIND);
207   gtk_widget_show (find_button);
208
209   buttonbox = get_widget_assert (fd.xml, "find-buttonbox");
210
211   gtk_box_pack_start_defaults (GTK_BOX (buttonbox), find_button);
212   gtk_box_reorder_child (GTK_BOX (buttonbox), find_button, 0);
213
214   dialog = get_widget_assert (fd.xml, "find-dialog");
215   source = get_widget_assert (fd.xml, "find-variable-treeview");
216   selector = get_widget_assert (fd.xml, "find-selector");
217
218   g_object_get (de->data_editor,
219                 "var-store", &vs,
220                 "data-store", &ds,
221                 NULL);
222
223   fd.dict = vs->dict;
224   fd.data = ds->case_file->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), de->parent.window);
243
244
245   attach_dictionary_to_treeview (GTK_TREE_VIEW (source),
246                                  fd.dict,
247                                  GTK_SELECTION_SINGLE,
248                                  NULL);
249
250   psppire_selector_set_subjects (PSPPIRE_SELECTOR (selector),
251                                  source,
252                                  fd.variable_entry,
253                                  insert_source_row_into_entry,
254                                  is_currently_in_entry,
255                                  NULL
256                                  );
257
258   g_signal_connect (dialog, "refresh", G_CALLBACK (refresh),  &fd);
259
260   g_signal_connect (find_button, "clicked", G_CALLBACK (do_find),  &fd);
261
262   g_signal_connect (selector, "selected",
263                     G_CALLBACK (on_select),  &fd);
264
265   g_signal_connect (selector, "de-selected",
266                     G_CALLBACK (on_deselect),  &fd);
267
268   g_signal_connect (fd.value_labels_checkbox, "toggled",
269                     G_CALLBACK (value_labels_toggled),  &fd);
270
271
272   psppire_dialog_run (PSPPIRE_DIALOG (dialog));
273
274   g_object_unref (fd.xml);
275 }
276
277 \f
278 /* Iterators */
279
280 static void
281 forward (casenumber *i, struct datasheet *data UNUSED)
282 {
283   ++*i;
284 }
285
286
287 static void
288 forward_wrap (casenumber *i, struct datasheet *data)
289 {
290   if ( ++*i >=  datasheet_get_row_cnt (data) ) *i = 0;
291 }
292
293 static void
294 backward (casenumber *i, struct datasheet *data UNUSED)
295 {
296   --*i;
297 }
298
299
300 static void
301 backward_wrap (casenumber *i, struct datasheet *data)
302 {
303   if ( --*i < 0 )
304     *i = datasheet_get_row_cnt (data) - 1;
305 }
306
307
308 /* Current plus one */
309 static casenumber
310 cp1 (casenumber current, struct datasheet *data)
311 {
312   return current + 1;
313 }
314
315 /* Current plus one, circular */
316 static casenumber
317 cp1c (casenumber current, struct datasheet *data)
318 {
319   casenumber next = current;
320
321   forward_wrap (&next, data);
322
323   return next;
324 }
325
326
327 /* Current minus one */
328 static casenumber
329 cm1 (casenumber current, struct datasheet *data)
330 {
331   return current - 1;
332 }
333
334 /* Current minus one, circular */
335 static casenumber
336 cm1c (casenumber current, struct datasheet *data)
337 {
338   casenumber next = current;
339
340   backward_wrap (&next, data);
341
342   return next;
343 }
344
345
346 static casenumber
347 last (casenumber current, struct datasheet *data)
348 {
349   return datasheet_get_row_cnt (data) ;
350 }
351
352 static casenumber
353 minus1 (casenumber current, struct datasheet *data)
354 {
355   return -1;
356 }
357
358 /* An type to facilitate iterating through casenumbers */
359 struct casenum_iterator
360 {
361   /* returns the first case to access */
362   casenumber (*start) (casenumber, struct datasheet *);
363
364   /* Returns one past the last case to access */
365   casenumber (*end) (casenumber, struct datasheet *);
366
367   /* Sets the first arg to the next case to access */
368   void (*next) (casenumber *, struct datasheet *);
369 };
370
371 enum iteration_type{
372   FORWARD = 0,
373   FORWARD_WRAP,
374   REVERSE,
375   REVERSE_WRAP,
376   n_iterators
377 };
378
379 static const struct casenum_iterator ip[n_iterators] =
380   {
381     {cp1, last, forward},
382     {cp1c, cm1, forward_wrap},
383     {cm1, minus1, backward},
384     {cm1c, cp1, backward_wrap}
385   };
386
387
388 \f
389 /* A factory returning an iterator according to the dialog box's settings */
390 static const struct casenum_iterator *
391 get_iteration_params (const struct find_dialog *fd)
392 {
393   gboolean wrap = gtk_toggle_button_get_active
394     (GTK_TOGGLE_BUTTON (get_widget_assert (fd->xml, "find-wrap")));
395
396   gboolean reverse = gtk_toggle_button_get_active
397     (GTK_TOGGLE_BUTTON (get_widget_assert (fd->xml, "find-backwards")));
398
399   if ( wrap )
400     {
401       if ( reverse )
402         return &ip[REVERSE_WRAP];
403       else
404         return &ip[FORWARD_WRAP];
405     }
406   else
407     {
408       if ( reverse )
409         return &ip[REVERSE];
410       else
411         return &ip[FORWARD];
412     }
413 }
414
415
416 enum string_cmp_flags
417   {
418     STR_CMP_SUBSTR = 0x01, /* Find strings which are substrings of the
419                               values */
420     STR_CMP_REGEXP = 0x02, /* Match against a regular expression */
421
422     STR_CMP_LABELS = 0x04  /* Match against the values' labels instead
423                               of the data */
424   };
425
426
427 /* An abstract base type for comparing union values against a reference */
428 struct comparator
429 {
430   const struct variable *var;
431   enum string_cmp_flags flags;
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 == compare_values (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   const struct string_comparator *ssc =
498     (const struct string_comparator *) cmptr;
499
500   const char *text = val->s;
501   int width = var_get_width (cmptr->var);
502
503   assert ( ! (cmptr->flags & STR_CMP_LABELS));
504
505   g_return_val_if_fail (width > 0, false);
506
507   if ( cmptr->flags & STR_CMP_SUBSTR)
508     return (NULL != g_strstr_len (text, width, ssc->pattern));
509   else
510     return (0 == strncmp (text, ssc->pattern, width));
511 }
512
513
514
515 /* Return true if VAL matched the regexp */
516 static bool
517 regexp_value_compare (const struct comparator *cmptr,
518                 const union value *val)
519 {
520   char *text;
521   bool retval;
522   const struct regexp_comparator *rec =
523     (const struct regexp_comparator *) cmptr;
524
525   int width = var_get_width (cmptr->var);
526
527   assert  ( ! (cmptr->flags & STR_CMP_LABELS) );
528
529   g_return_val_if_fail (width > 0, false);
530
531   /* We must remove trailing whitespace, otherwise $ will not match where
532      one would expect */
533   text = g_strndup (val->s, width);
534   g_strchomp (text);
535
536   retval = (0 == regexec (&rec->re, text, 0, 0, 0));
537
538   g_free (text);
539
540   return retval;
541 }
542
543 /* Return true if the label of VAL matched the regexp */
544 static bool
545 regexp_label_compare (const struct comparator *cmptr,
546                       const union value *val)
547 {
548   const char *text;
549   const struct regexp_comparator *rec =
550     (const struct regexp_comparator *) cmptr;
551
552   int width ;
553
554   assert ( cmptr->flags & STR_CMP_LABELS);
555
556   text = var_lookup_value_label (cmptr->var, val);
557   width = strlen (text);
558
559   g_return_val_if_fail (width > 0, false);
560
561   return (0 == regexec (&rec->re, text, 0, 0, 0));
562 }
563
564
565
566 static void
567 regexp_destroy (struct comparator *cmptr)
568 {
569   struct regexp_comparator *rec = (struct regexp_comparator *) cmptr;
570
571   regfree (&rec->re);
572 }
573
574 static void
575 value_destroy (struct comparator *cmptr)
576 {
577   struct value_comparator *vc = (struct value_comparator *) cmptr;
578   free (vc->pattern);
579 }
580
581
582 static struct comparator *
583 value_comparator_create (const struct variable *var, const char *target)
584 {
585   const struct fmt_spec *fmt;
586   int width ;
587   struct value_comparator *vc = xzalloc (sizeof (*vc));
588   struct comparator *cmptr = (struct comparator *) vc;
589
590   cmptr->flags = 0;
591   cmptr->var = var;
592   cmptr->compare  = value_compare ;
593   cmptr->destroy = value_destroy;
594
595   width = var_get_width (var);
596   fmt = var_get_write_format (var);
597
598   vc->pattern = value_create (width);
599
600   if ( ! data_in (ss_cstr (target),
601                   LEGACY_NATIVE,
602                   fmt->type,
603                   0, 0, 0,
604                   vc->pattern, width) )
605     {
606       free (vc);
607       return NULL;
608     }
609
610   return cmptr;
611 }
612
613 static struct comparator *
614 string_comparator_create (const struct variable *var, const char *target,
615                           enum string_cmp_flags flags)
616 {
617   struct string_comparator *ssc = xzalloc (sizeof (*ssc));
618   struct comparator *cmptr = (struct comparator *) ssc;
619
620   cmptr->flags = flags;
621   cmptr->var = var;
622
623   if ( flags & STR_CMP_LABELS)
624     cmptr->compare = string_label_compare;
625   else
626     cmptr->compare = string_value_compare;
627
628   ssc->pattern = target;
629
630   return cmptr;
631 }
632
633
634 static struct comparator *
635 regexp_comparator_create (const struct variable *var, const char *target,
636                           enum string_cmp_flags flags)
637 {
638   int code;
639   struct regexp_comparator *rec = xzalloc (sizeof (*rec));
640   struct comparator *cmptr = (struct comparator *) rec;
641
642   cmptr->flags = flags;
643   cmptr->var = var;
644   cmptr->compare  = (flags & STR_CMP_LABELS)
645     ? regexp_label_compare : regexp_value_compare ;
646
647   cmptr->destroy  = regexp_destroy;
648
649   code = regcomp (&rec->re, target, 0);
650   if ( code != 0 )
651     {
652       char *errbuf = NULL;
653       size_t errbuf_size = regerror (code, &rec->re, errbuf,  0);
654
655       errbuf = xmalloc (errbuf_size);
656
657       regerror (code, &rec->re, errbuf, errbuf_size);
658
659       msg (ME, _("Bad regular expression: %s"), errbuf);
660
661       free ( cmptr);
662       free (errbuf);
663       return NULL;
664     }
665
666   return cmptr;
667 }
668
669
670 /* Compare V against CMPTR's reference */
671 static bool
672 comparator_compare (const struct comparator *cmptr,
673                     const union value *v)
674 {
675   return cmptr->compare (cmptr, v);
676 }
677
678 /* Destroy CMPTR */
679 static void
680 comparator_destroy (struct comparator *cmptr)
681 {
682   if ( ! cmptr )
683     return ;
684
685   if ( cmptr->destroy )
686     cmptr->destroy (cmptr);
687
688   free (cmptr);
689 }
690
691
692 static struct comparator *
693 comparator_factory (const struct variable *var, const char *str,
694                     enum string_cmp_flags flags)
695 {
696   if ( flags & STR_CMP_REGEXP )
697     return regexp_comparator_create (var, str, flags);
698
699   if ( flags & (STR_CMP_SUBSTR | STR_CMP_LABELS) )
700     return string_comparator_create (var, str, flags);
701
702   return value_comparator_create (var, str);
703 }
704
705
706 /* Find the row and column specified by the dialog FD, starting at CURRENT_ROW.
707    After the function returns, *ROW contains the row and *COLUMN the column.
708    If no such case is found, then *ROW will be set to -1
709  */
710 static void
711 find_value (const struct find_dialog *fd, casenumber current_row,
712            casenumber *row, int *column)
713 {
714   int width;
715   const struct variable *var;
716   const char *var_name = gtk_entry_get_text (GTK_ENTRY (fd->variable_entry));
717   const char *target_string = gtk_entry_get_text (GTK_ENTRY (fd->value_entry));
718
719   enum string_cmp_flags flags = 0;
720   g_assert (current_row >= 0);
721
722   var = dict_lookup_var (fd->dict->dict, var_name);
723   if ( ! var )
724     return ;
725
726   width = var_get_width (var);
727
728   *column = var_get_dict_index (var);
729   *row = -1;
730
731   if ( gtk_toggle_button_get_active
732        (GTK_TOGGLE_BUTTON (fd->match_substring_checkbox)))
733     flags |= STR_CMP_SUBSTR;
734
735   if ( gtk_toggle_button_get_active
736        (GTK_TOGGLE_BUTTON (fd->match_regexp_checkbox)))
737     flags |= STR_CMP_REGEXP;
738
739   if ( gtk_toggle_button_get_active
740        (GTK_TOGGLE_BUTTON (fd->value_labels_checkbox)))
741     flags |= STR_CMP_LABELS;
742
743   {
744     union value *val = value_create (width);
745     casenumber i;
746     const struct casenum_iterator *ip = get_iteration_params (fd);
747     struct comparator *cmptr =
748       comparator_factory (var, target_string, flags);
749
750     if ( ! cmptr)
751       goto finish;
752
753     for (i = ip->start (current_row, fd->data);
754          i != ip->end (current_row, fd->data);
755          ip->next (&i, fd->data))
756       {
757         datasheet_get_value (fd->data, i, var_get_case_index (var),
758                              val, width);
759
760         if ( comparator_compare (cmptr, val))
761           {
762             *row = i;
763             break;
764           }
765       }
766
767   finish:
768     comparator_destroy (cmptr);
769     free (val);
770   }
771 }