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