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