?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r1996: Cope slightly better with invalid filenames in various places (reported by
[rox-filer.git] / ROX-Filer / src / minibuffer.c
blobe7e78e22d79e2014d12ea0c46509481ca33dd5bc
1 /*
2 * $Id$
3 *
4 * ROX-Filer, filer for the ROX desktop project
5 * Copyright (C) 2002, the ROX-Filer team.
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the Free
9 * Software Foundation; either version 2 of the License, or (at your option)
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * more details.
16 *
17 * You should have received a copy of the GNU General Public License along with
18 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
19 * Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 /* minibuffer.c - for handling the path entry box at the bottom */
23
24 #include "config.h"
25
26 #include <string.h>
27 #include <errno.h>
28 #include <ctype.h>
29 #include <glob.h>
30 #include <stdio.h>
31
32 #include <gtk/gtk.h>
33 #include <gdk/gdkkeysyms.h>
34
35 #include "global.h"
36
37 #include "options.h"
38 #include "find.h"
39 #include "gui_support.h"
40 #include "support.h"
41 #include "minibuffer.h"
42 #include "filer.h"
43 #include "display.h"
44 #include "main.h"
45 #include "action.h"
46 #include "diritem.h"
47 #include "type.h"
48 #include "view_iface.h"
49
50 static GList *shell_history = NULL;
51
52 /* Static prototypes */
53 static gint key_press_event(GtkWidget *widget,
54 GdkEventKey *event,
55 FilerWindow *filer_window);
56 static void changed(GtkEditable *mini, FilerWindow *filer_window);
57 static gboolean find_next_match(FilerWindow *filer_window,
58 const char *pattern,
59 int dir);
60 static gboolean find_exact_match(FilerWindow *filer_window,
61 const gchar *pattern);
62 static gboolean matches(ViewIter *iter, const char *pattern);
63 static void search_in_dir(FilerWindow *filer_window, int dir);
64 static const gchar *mini_contents(FilerWindow *filer_window);
65 static void show_help(FilerWindow *filer_window);
66 static gboolean grab_focus(GtkWidget *minibuffer);
67
68 /****************************************************************
69 * EXTERNAL INTERFACE *
70 ****************************************************************/
71
72 static Option o_filer_beep_fail, o_filer_beep_multi;
73
74 void minibuffer_init(void)
75 {
76 option_add_int(&o_filer_beep_fail, "filer_beep_fail", 1);
77 option_add_int(&o_filer_beep_multi, "filer_beep_multi", 1);
78 }
79
80 /* Creates the minibuffer widgets, setting the appropriate fields
81 * in filer_window.
82 */
83 void create_minibuffer(FilerWindow *filer_window)
84 {
85 GtkWidget *hbox, *label, *mini;
86
87 hbox = gtk_hbox_new(FALSE, 0);
88
89 gtk_box_pack_start(GTK_BOX(hbox),
90 new_help_button((HelpFunc) show_help, filer_window),
91 FALSE, TRUE, 0);
92
93 label = gtk_label_new("");
94 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 2);
95
96 mini = gtk_entry_new();
97 gtk_box_pack_start(GTK_BOX(hbox), mini, TRUE, TRUE, 0);
98 gtk_widget_set_name(mini, "fixed-style");
99 g_signal_connect(mini, "key_press_event",
100 G_CALLBACK(key_press_event), filer_window);
101 g_signal_connect(mini, "changed", G_CALLBACK(changed), filer_window);
102
103 /* Grabbing focus musn't select the text... */
104 g_signal_connect_swapped(mini, "grab-focus",
105 G_CALLBACK(grab_focus), mini);
106
107 filer_window->minibuffer = mini;
108 filer_window->minibuffer_label = label;
109 filer_window->minibuffer_area = hbox;
110 }
111
112 void minibuffer_show(FilerWindow *filer_window, MiniType mini_type)
113 {
114 GtkEntry *mini;
115 int pos = -1;
116 ViewIter cursor;
117
118 g_return_if_fail(filer_window != NULL);
119 g_return_if_fail(filer_window->minibuffer != NULL);
120
121 mini = GTK_ENTRY(filer_window->minibuffer);
122 entry_set_error(filer_window->minibuffer, FALSE);
123
124 filer_window->mini_type = MINI_NONE;
125 gtk_label_set_text(GTK_LABEL(filer_window->minibuffer_label),
126 mini_type == MINI_PATH ? _("Goto:") :
127 mini_type == MINI_SHELL ? _("Shell:") :
128 mini_type == MINI_SELECT_IF ? _("Select If:") :
129 "?");
130
131 switch (mini_type)
132 {
133 case MINI_PATH:
134 view_show_cursor(filer_window->view);
135 view_get_cursor(filer_window->view, &cursor);
136 view_set_base(filer_window->view, &cursor);
137
138 gtk_entry_set_text(mini,
139 make_path(filer_window->sym_path, "")->str);
140 if (filer_window->temp_show_hidden)
141 {
142 display_set_hidden(filer_window, FALSE);
143 filer_window->temp_show_hidden = FALSE;
144 }
145 break;
146 case MINI_SELECT_IF:
147 gtk_entry_set_text(mini, "");
148 filer_window->mini_cursor_base = -1; /* History */
149 break;
150 case MINI_SHELL:
151 {
152 DirItem *item;
153 view_get_cursor(filer_window->view, &cursor);
154 item = cursor.peek(&cursor);
155 pos = 0;
156 if (view_count_selected(filer_window->view) > 0)
157 gtk_entry_set_text(mini, " \"$@\"");
158 else if (item)
159 {
160 guchar *tmp;
161
162 tmp = g_strconcat(" ", item->leafname, NULL);
163 gtk_entry_set_text(mini, tmp);
164 g_free(tmp);
165 }
166 else
167 gtk_entry_set_text(mini, "");
168 filer_window->mini_cursor_base = -1; /* History */
169 break;
170 }
171 default:
172 g_warning("Bad minibuffer type\n");
173 return;
174 }
175
176 filer_window->mini_type = mini_type;
177
178 gtk_editable_set_position(GTK_EDITABLE(mini), pos);
179
180 gtk_widget_show_all(filer_window->minibuffer_area);
181
182 gtk_widget_grab_focus(filer_window->minibuffer);
183 }
184
185 void minibuffer_hide(FilerWindow *filer_window)
186 {
187 filer_window->mini_type = MINI_NONE;
188
189 gtk_widget_hide(filer_window->minibuffer_area);
190
191 gtk_widget_child_focus(filer_window->window, GTK_DIR_TAB_FORWARD);
192
193 if (filer_window->temp_show_hidden)
194 {
195 DirItem *item;
196 ViewIter iter;
197
198 view_get_cursor(filer_window->view, &iter);
199 item = iter.peek(&iter);
200
201 if (item == NULL || item->leafname[0] != '.')
202 display_set_hidden(filer_window, FALSE);
203 filer_window->temp_show_hidden = FALSE;
204 }
205 }
206
207 /* Insert this leafname at the cursor (replacing the selection, if any).
208 * Must be in SHELL mode.
209 */
210 void minibuffer_add(FilerWindow *filer_window, const gchar *leafname)
211 {
212 guchar *esc;
213 GtkEditable *edit = GTK_EDITABLE(filer_window->minibuffer);
214 GtkEntry *entry = GTK_ENTRY(edit);
215 int pos;
216
217 g_return_if_fail(filer_window->mini_type == MINI_SHELL);
218
219 esc = shell_escape(leafname);
220
221 gtk_editable_delete_selection(edit);
222 pos = gtk_editable_get_position(edit);
223
224 if (pos > 0 && gtk_entry_get_text(entry)[pos - 1] != ' ')
225 gtk_editable_insert_text(edit, " ", 1, &pos);
226
227 gtk_editable_insert_text(edit, esc, strlen(esc), &pos);
228 gtk_editable_set_position(edit, pos);
229
230 g_free(esc);
231 }
232
233
234 /****************************************************************
235 * INTERNAL FUNCTIONS *
236 ****************************************************************/
237
238 static void show_help(FilerWindow *filer_window)
239 {
240 switch (filer_window->mini_type)
241 {
242 case MINI_PATH:
243 info_message(
244 _("Enter the name of a file and I'll display "
245 "it for you. Press Tab to fill in the longest "
246 "match. Escape to close the minibuffer."));
247 break;
248 case MINI_SHELL:
249 info_message(
250 _("Enter a shell command to execute. Click "
251 "on a file to add it to the buffer."));
252 break;
253 case MINI_SELECT_IF:
254 show_condition_help(NULL);
255 break;
256 default:
257 g_warning("Unknown minibuffer type!");
258 break;
259 }
260 }
261
262
263 /* PATH ENTRY */
264
265 static void path_return_pressed(FilerWindow *filer_window, GdkEventKey *event)
266 {
267 const gchar *path, *pattern;
268 int flags = OPEN_FROM_MINI | OPEN_SAME_WINDOW;
269 ViewIter iter;
270 DirItem *item;
271
272 path = gtk_entry_get_text(GTK_ENTRY(filer_window->minibuffer));
273 pattern = g_basename(path);
274
275 view_get_cursor(filer_window->view, &iter);
276
277 item = iter.peek(&iter);
278 if (item == NULL || !matches(&iter, pattern))
279 {
280 gdk_beep();
281 return;
282 }
283
284 if ((event->state & GDK_SHIFT_MASK) != 0)
285 flags |= OPEN_SHIFT;
286
287 filer_openitem(filer_window, &iter, flags);
288 }
289
290 /* Use the cursor item to fill in the minibuffer.
291 * If there are multiple matches then fill in as much as possible and
292 * (possibly) beep.
293 */
294 static void complete(FilerWindow *filer_window)
295 {
296 GtkEntry *entry;
297 DirItem *item, *other;
298 int shortest_stem = -1;
299 int current_stem;
300 const gchar *text, *leaf;
301 ViewIter cursor, iter;
302
303 view_get_cursor(filer_window->view, &cursor);
304 item = cursor.peek(&cursor);
305
306 if (!item)
307 {
308 gdk_beep();
309 return;
310 }
311
312 entry = GTK_ENTRY(filer_window->minibuffer);
313
314 text = gtk_entry_get_text(entry);
315 leaf = strrchr(text, '/');
316 if (!leaf)
317 {
318 gdk_beep();
319 return;
320 }
321
322 leaf++;
323 if (!matches(&cursor, leaf))
324 {
325 gdk_beep();
326 return;
327 }
328
329 current_stem = strlen(leaf);
330
331 /* Find the longest other match of this name. It it's longer than
332 * the currently entered text then complete only up to that length.
333 */
334 view_get_iter(filer_window->view, &iter, 0);
335 while ((other = iter.next(&iter)))
336 {
337 int stem = 0;
338
339 if (iter.i == cursor.i) /* XXX */
340 continue;
341
342 while (other->leafname[stem] && item->leafname[stem])
343 {
344 if (other->leafname[stem] != item->leafname[stem])
345 break;
346 stem++;
347 }
348
349 /* stem is the index of the first difference */
350 if (stem >= current_stem &&
351 (shortest_stem == -1 || stem < shortest_stem))
352 shortest_stem = stem;
353 }
354
355 if (current_stem == shortest_stem)
356 {
357 /* We didn't add anything... */
358 if (o_filer_beep_fail.int_value)
359 gdk_beep();
360 }
361 else if (current_stem < shortest_stem)
362 {
363 guchar *extra;
364 gint tmp_pos;
365
366 extra = g_strndup(item->leafname + current_stem,
367 shortest_stem - current_stem);
368
369 tmp_pos = entry->text_length;
370 gtk_editable_insert_text(GTK_EDITABLE(entry), extra, -1,
371 &tmp_pos);
372
373 g_free(extra);
374 gtk_editable_set_position(GTK_EDITABLE(entry), -1);
375
376 if (o_filer_beep_multi.int_value)
377 gdk_beep();
378 }
379 else
380 {
381 GString *new;
382
383 new = make_path(filer_window->sym_path, item->leafname);
384
385 if (item->base_type == TYPE_DIRECTORY &&
386 (item->flags & ITEM_FLAG_APPDIR) == 0)
387 g_string_append_c(new, '/');
388
389 gtk_entry_set_text(entry, new->str);
390 gtk_editable_set_position(GTK_EDITABLE(entry), -1);
391 }
392 }
393
394 static void path_changed(FilerWindow *filer_window)
395 {
396 GtkWidget *mini = filer_window->minibuffer;
397 const char *new, *leaf;
398 char *path;
399 gboolean error = FALSE;
400
401 new = gtk_entry_get_text(GTK_ENTRY(mini));
402
403 if (!*new)
404 {
405 /* Entry may be blank because we're in the middle of changing
406 * to something else...
407 */
408 entry_set_error(mini, FALSE);
409 return;
410 }
411
412 leaf = g_basename(new);
413 if (leaf == new)
414 path = g_strdup("/");
415 else
416 path = g_dirname(new);
417
418 if (strcmp(path, filer_window->sym_path) != 0)
419 {
420 /* The new path is in a different directory */
421 struct stat info;
422
423 if (mc_stat(path, &info) == 0 && S_ISDIR(info.st_mode))
424 filer_change_to(filer_window, path, leaf);
425 else
426 error = TRUE;
427 }
428 else
429 {
430 if (*leaf == '.')
431 {
432 if (!filer_window->show_hidden)
433 {
434 filer_window->temp_show_hidden = TRUE;
435 display_set_hidden(filer_window, TRUE);
436 }
437 }
438 else if (filer_window->temp_show_hidden)
439 {
440 display_set_hidden(filer_window, FALSE);
441 filer_window->temp_show_hidden = FALSE;
442 }
443
444 if (find_exact_match(filer_window, leaf) == FALSE &&
445 find_next_match(filer_window, leaf, 0) == FALSE)
446 error = TRUE;
447 }
448
449 g_free(path);
450
451 entry_set_error(mini, error);
452 }
453
454 /* Look for an exact match, and move the cursor to it if found.
455 * TRUE on success.
456 */
457 static gboolean find_exact_match(FilerWindow *filer_window,
458 const gchar *pattern)
459 {
460 DirItem *item;
461 ViewIter iter;
462 ViewIface *view = filer_window->view;
463
464 view_get_iter(view, &iter, 0);
465
466 while ((item = iter.next(&iter)))
467 {
468 if (strcmp(item->leafname, pattern) == 0)
469 {
470 view_cursor_to_iter(view, &iter);
471 return TRUE;
472 }
473 }
474
475 return FALSE;
476 }
477
478 /* Find the next item in the view that matches 'pattern'. Start from
479 * cursor_base and loop at either end. dir is 1 for a forward search,
480 * -1 for backwards. 0 means forwards, but may stay the same.
481 *
482 * Does not automatically update cursor_base.
483 *
484 * Returns TRUE if a match is found.
485 */
486 static gboolean find_next_match(FilerWindow *filer_window,
487 const char *pattern,
488 int dir)
489 {
490 ViewIface *view = filer_window->view;
491 ViewIter iter;
492
493 if (view_count_items(view) < 1)
494 return FALSE;
495
496 view_get_iter(view, &iter,
497 VIEW_ITER_FROM_BASE |
498 (dir >= 0 ? 0 : VIEW_ITER_BACKWARDS));
499
500 if (dir != 0)
501 iter.next(&iter); /* Don't look at the base itself */
502
503 while (iter.next(&iter))
504 {
505 if (matches(&iter, pattern))
506 {
507 view_cursor_to_iter(view, &iter);
508 return TRUE;
509 }
510 }
511
512 /* No matches (except possibly base itself) */
513 view_get_iter(view, &iter,
514 VIEW_ITER_FROM_BASE | VIEW_ITER_ONE_ONLY |
515 (dir >= 0 ? 0 : VIEW_ITER_BACKWARDS));
516
517 view_cursor_to_iter(view, &iter);
518
519 return FALSE;
520 }
521
522 static gboolean matches(ViewIter *iter, const char *pattern)
523 {
524 DirItem *item;
525
526 item = iter->peek(iter);
527
528 return strncmp(item->leafname, pattern, strlen(pattern)) == 0;
529 }
530
531 /* Find next match and set base for future matches. */
532 static void search_in_dir(FilerWindow *filer_window, int dir)
533 {
534 const char *path, *pattern;
535 ViewIter iter;
536
537 path = gtk_entry_get_text(GTK_ENTRY(filer_window->minibuffer));
538 pattern = g_basename(path);
539
540 view_get_cursor(filer_window->view, &iter);
541 view_set_base(filer_window->view, &iter);
542 find_next_match(filer_window, pattern, dir);
543 view_get_cursor(filer_window->view, &iter);
544 view_set_base(filer_window->view, &iter);
545 }
546
547 /* SHELL COMMANDS */
548
549 static void add_to_history(const gchar *line)
550 {
551 guchar *last;
552
553 last = shell_history ? (guchar *) shell_history->data : NULL;
554
555 if (last && strcmp(last, line) == 0)
556 return; /* Duplicating last entry */
557
558 shell_history = g_list_prepend(shell_history, g_strdup(line));
559 }
560
561 static void shell_done(FilerWindow *filer_window)
562 {
563 if (filer_exists(filer_window))
564 filer_update_dir(filer_window, TRUE);
565 }
566
567 /* Given a list of matches, return the longest stem. g_free() the result.
568 * Special chars are escaped. If there is only a single (non-dir) match
569 * then a trailing space is added.
570 */
571 static guchar *best_match(FilerWindow *filer_window, glob_t *matches)
572 {
573 gchar *first = matches->gl_pathv[0];
574 int i;
575 int longest, path_len;
576 guchar *path, *tmp;
577
578 longest = strlen(first);
579
580 for (i = 1; i < matches->gl_pathc; i++)
581 {
582 int j;
583 guchar *m = matches->gl_pathv[i];
584
585 for (j = 0; j < longest; j++)
586 if (m[j] != first[j])
587 longest = j;
588 }
589
590 path_len = strlen(filer_window->sym_path);
591 if (strncmp(filer_window->sym_path, first, path_len) == 0 &&
592 first[path_len] == '/' && first[path_len + 1])
593 {
594 path = g_strndup(first + path_len + 1, longest - path_len - 1);
595 }
596 else
597 path = g_strndup(first, longest);
598
599 tmp = shell_escape(path);
600 g_free(path);
601
602 if (matches->gl_pathc == 1 && tmp[strlen(tmp) - 1] != '/')
603 {
604 path = g_strdup_printf("%s ", tmp);
605 g_free(tmp);
606 return path;
607 }
608
609 return tmp;
610 }
611
612 static void shell_tab(FilerWindow *filer_window)
613 {
614 const gchar *entry;
615 int i;
616 int pos;
617 GString *leaf;
618 glob_t matches;
619 int leaf_start;
620
621 entry = gtk_entry_get_text(GTK_ENTRY(filer_window->minibuffer));
622 pos = gtk_editable_get_position(GTK_EDITABLE(filer_window->minibuffer));
623 leaf = g_string_new(NULL);
624
625 for (i = 0; i < pos; i++)
626 {
627 guchar c = entry[i];
628
629 if (leaf->len == 0)
630 leaf_start = i;
631
632 if (c == ' ')
633 {
634 g_string_truncate(leaf, 0);
635 continue;
636 }
637 else if (c == '\\' && i + 1 < pos)
638 c = entry[++i];
639 else if (c == '"' || c == '\'')
640 {
641 for (++i; i < pos; i++)
642 {
643 guchar cc = entry[i];
644
645 if (cc == '\\' && i + 1 < pos)
646 cc = entry[++i];
647 else if (cc == c)
648 break;
649 g_string_append_c(leaf, cc);
650 }
651 continue;
652 }
653
654 g_string_append_c(leaf, c);
655 }
656
657 if (leaf->len == 0)
658 leaf_start = pos;
659
660 if (leaf->str[0] != '/' && leaf->str[0] != '~')
661 {
662 g_string_prepend_c(leaf, '/');
663 g_string_prepend(leaf, filer_window->sym_path);
664 }
665
666 g_string_append_c(leaf, '*');
667
668 if (glob(leaf->str,
669 #ifdef GLOB_TILDE
670 GLOB_TILDE |
671 #endif
672 GLOB_MARK, NULL, &matches) == 0)
673 {
674 if (matches.gl_pathc > 0)
675 {
676 guchar *best;
677 GtkEditable *edit =
678 GTK_EDITABLE(filer_window->minibuffer);
679
680 best = best_match(filer_window, &matches);
681
682 gtk_editable_delete_text(edit, leaf_start, pos);
683 gtk_editable_insert_text(edit, best, strlen(best),
684 &leaf_start);
685 gtk_editable_set_position(edit, leaf_start);
686
687 g_free(best);
688 }
689 if (matches.gl_pathc != 1)
690 gdk_beep();
691
692 globfree(&matches);
693 }
694
695 g_string_free(leaf, TRUE);
696 }
697
698 static void run_child(gpointer unused)
699 {
700 /* Ensure output is noticed - send stdout to stderr */
701 dup2(STDERR_FILENO, STDOUT_FILENO);
702 close_on_exec(STDOUT_FILENO, FALSE);
703 }
704
705 /* Either execute the command or make it the default run action */
706 static void shell_return_pressed(FilerWindow *filer_window)
707 {
708 GPtrArray *argv;
709 const gchar *entry;
710 GError *error = NULL;
711 pid_t child;
712 DirItem *item;
713 ViewIter iter;
714
715 entry = mini_contents(filer_window);
716
717 if (!entry)
718 goto out;
719
720 add_to_history(entry);
721
722 argv = g_ptr_array_new();
723 g_ptr_array_add(argv, "sh");
724 g_ptr_array_add(argv, "-c");
725 g_ptr_array_add(argv, (gchar *) entry);
726 g_ptr_array_add(argv, "sh");
727
728 view_get_iter(filer_window->view, &iter, 0);
729 while ((item = iter.next(&iter)))
730 {
731 if (view_get_selected(filer_window->view, &iter))
732 g_ptr_array_add(argv, item->leafname);
733 }
734
735 g_ptr_array_add(argv, NULL);
736
737 if (!g_spawn_async_with_pipes(filer_window->sym_path,
738 (gchar **) argv->pdata, NULL,
739 G_SPAWN_DO_NOT_REAP_CHILD |
740 G_SPAWN_SEARCH_PATH,
741 run_child, NULL, /* Child setup fn */
742 &child, /* Child PID */
743 NULL, NULL, NULL, /* Standard pipes */
744 &error))
745 {
746 delayed_error("%s", error ? error->message : "(null)");
747 g_error_free(error);
748 }
749 else
750 on_child_death(child, (CallbackFn) shell_done, filer_window);
751
752 g_ptr_array_free(argv, TRUE);
753
754 out:
755 minibuffer_hide(filer_window);
756 }
757
758 /* Move through the shell history */
759 static void shell_recall(FilerWindow *filer_window, int dir)
760 {
761 guchar *command;
762 int pos = filer_window->mini_cursor_base;
763
764 pos += dir;
765 if (pos >= 0)
766 {
767 command = g_list_nth_data(shell_history, pos);
768 if (!command)
769 return;
770 }
771 else
772 command = "";
773
774 if (pos < -1)
775 pos = -1;
776 filer_window->mini_cursor_base = pos;
777
778 gtk_entry_set_text(GTK_ENTRY(filer_window->minibuffer), command);
779 }
780
781 /* SELECT IF */
782
783 typedef struct {
784 FindInfo info;
785 FilerWindow *filer_window;
786 FindCondition *cond;
787 } SelectData;
788
789 static gboolean select_if_test(ViewIter *iter, gpointer user_data)
790 {
791 DirItem *item;
792 SelectData *data = user_data;
793
794 item = iter->peek(iter);
795 g_return_val_if_fail(item != NULL, FALSE);
796
797 data->info.leaf = item->leafname;
798 data->info.fullpath = make_path(data->filer_window->sym_path,
799 data->info.leaf)->str;
800
801 return lstat(data->info.fullpath, &data->info.stats) == 0 &&
802 find_test_condition(data->cond, &data->info);
803 }
804
805 static void select_return_pressed(FilerWindow *filer_window, guint etime)
806 {
807 const gchar *entry;
808 SelectData data;
809
810 entry = mini_contents(filer_window);
811
812 if (!entry)
813 goto out;
814
815 add_to_history(entry);
816
817 data.cond = find_compile(entry);
818 if (!data.cond)
819 {
820 delayed_error(_("Invalid Find condition"));
821 return;
822 }
823
824 data.info.now = time(NULL);
825 data.info.prune = FALSE; /* (don't care) */
826 data.filer_window = filer_window;
827
828 view_select_if(filer_window->view, select_if_test, &data);
829
830 find_condition_free(data.cond);
831 out:
832 minibuffer_hide(filer_window);
833 }
834
835
836 /* EVENT HANDLERS */
837
838 static gint key_press_event(GtkWidget *widget,
839 GdkEventKey *event,
840 FilerWindow *filer_window)
841 {
842 if (event->keyval == GDK_Escape)
843 {
844 if (filer_window->mini_type == MINI_SHELL)
845 {
846 const gchar *line;
847
848 line = mini_contents(filer_window);
849 if (line)
850 add_to_history(line);
851 }
852
853 minibuffer_hide(filer_window);
854 return TRUE;
855 }
856
857 switch (filer_window->mini_type)
858 {
859 case MINI_PATH:
860 switch (event->keyval)
861 {
862 case GDK_Up:
863 search_in_dir(filer_window, -1);
864 break;
865 case GDK_Down:
866 search_in_dir(filer_window, 1);
867 break;
868 case GDK_Return:
869 case GDK_KP_Enter:
870 path_return_pressed(filer_window,
871 event);
872 break;
873 case GDK_Tab:
874 complete(filer_window);
875 break;
876 default:
877 return FALSE;
878 }
879 break;
880
881 case MINI_SHELL:
882 switch (event->keyval)
883 {
884 case GDK_Up:
885 shell_recall(filer_window, 1);
886 break;
887 case GDK_Down:
888 shell_recall(filer_window, -1);
889 break;
890 case GDK_Tab:
891 shell_tab(filer_window);
892 break;
893 case GDK_Return:
894 case GDK_KP_Enter:
895 shell_return_pressed(filer_window);
896 break;
897 default:
898 return FALSE;
899 }
900 break;
901 case MINI_SELECT_IF:
902 switch (event->keyval)
903 {
904 case GDK_Up:
905 shell_recall(filer_window, 1);
906 break;
907 case GDK_Down:
908 shell_recall(filer_window, -1);
909 break;
910 case GDK_Tab:
911 break;
912 case GDK_Return:
913 case GDK_KP_Enter:
914 select_return_pressed(filer_window,
915 event->time);
916 break;
917 default:
918 return FALSE;
919 }
920 break;
921 default:
922 break;
923 }
924
925 return TRUE;
926 }
927
928 static void changed(GtkEditable *mini, FilerWindow *filer_window)
929 {
930 switch (filer_window->mini_type)
931 {
932 case MINI_PATH:
933 path_changed(filer_window);
934 return;
935 case MINI_SELECT_IF:
936 set_find_string_colour(GTK_WIDGET(mini),
937 gtk_entry_get_text(
938 GTK_ENTRY(filer_window->minibuffer)));
939 return;
940 default:
941 break;
942 }
943 }
944
945 /* Returns a string (which must NOT be freed), or NULL if the buffer
946 * is blank (whitespace only).
947 */
948 static const gchar *mini_contents(FilerWindow *filer_window)
949 {
950 const gchar *entry, *c;
951
952 entry = gtk_entry_get_text(GTK_ENTRY(filer_window->minibuffer));
953
954 for (c = entry; *c; c++)
955 if (!isspace(*c))
956 return entry;
957
958 return NULL;
959 }
960
961 /* This is a really ugly hack to get around Gtk+-2.0's broken auto-select
962 * behaviour.
963 */
964 static gboolean grab_focus(GtkWidget *minibuffer)
965 {
966 GtkWidgetClass *class;
967
968 class = GTK_WIDGET_CLASS(gtk_type_class(GTK_TYPE_WIDGET));
969
970 class->grab_focus(minibuffer);
971
972 g_signal_stop_emission(minibuffer,
973 g_signal_lookup("grab_focus", G_OBJECT_TYPE(minibuffer)), 0);
974
975
976 return 1;
977 }
Filer for the ROX desktop