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