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