?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r1322: Converted MaskedPixmap to GObject.
[rox-filer.git] / ROX-Filer / src / minibuffer.c
blob5eb11c5f543a57d3c858fbb7967d24b81b9fcac9
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 const char *pattern,
59 int dir);
60 static gboolean find_exact_match(FilerWindow *filer_window,
61 const gchar *pattern);
62 static gboolean matches(Collection *collection, int item, 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 Collection *collection;
115 GtkEntry *mini;
116 int pos = -1, i;
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
123 filer_window->mini_type = MINI_NONE;
124 gtk_label_set_text(GTK_LABEL(filer_window->minibuffer_label),
125 mini_type == MINI_PATH ? _("Goto:") :
126 mini_type == MINI_SHELL ? _("Shell:") :
127 mini_type == MINI_SELECT_IF ? _("Select If:") :
128 "?");
129
130 collection = filer_window->collection;
131 switch (mini_type)
132 {
133 case MINI_PATH:
134 collection_move_cursor(collection, 0, 0);
135 filer_window->mini_cursor_base =
136 MAX(collection->cursor_item, 0);
137 gtk_entry_set_text(mini,
138 make_path(filer_window->path, "")->str);
139 if (filer_window->temp_show_hidden)
140 {
141 display_set_hidden(filer_window, FALSE);
142 filer_window->temp_show_hidden = FALSE;
143 }
144 break;
145 case MINI_SELECT_IF:
146 gtk_entry_set_text(mini, "");
147 filer_window->mini_cursor_base = -1; /* History */
148 break;
149 case MINI_SHELL:
150 pos = 0;
151 i = collection->cursor_item;
152 if (collection->number_selected)
153 gtk_entry_set_text(mini, " \"$@\"");
154 else if (i > -1 && i < collection->number_of_items)
155 {
156 DirItem *item = (DirItem *)
157 collection->items[i].data;
158 guchar *tmp;
159
160 tmp = g_strconcat(" ", item->leafname, NULL);
161 gtk_entry_set_text(mini, tmp);
162 g_free(tmp);
163 }
164 else
165 gtk_entry_set_text(mini, "");
166 filer_window->mini_cursor_base = -1; /* History */
167 break;
168 default:
169 g_warning("Bad minibuffer type\n");
170 return;
171 }
172
173 filer_window->mini_type = mini_type;
174
175 gtk_editable_set_position(GTK_EDITABLE(mini), pos);
176
177 gtk_widget_show_all(filer_window->minibuffer_area);
178
179 gtk_window_set_focus(GTK_WINDOW(filer_window->window),
180 filer_window->minibuffer);
181 }
182
183 void minibuffer_hide(FilerWindow *filer_window)
184 {
185 filer_window->mini_type = MINI_NONE;
186
187 gtk_widget_hide(filer_window->minibuffer_area);
188 gtk_window_set_focus(GTK_WINDOW(filer_window->window),
189 GTK_WIDGET(filer_window->collection));
190
191 if (filer_window->temp_show_hidden)
192 {
193 Collection *collection = filer_window->collection;
194 int i = collection->cursor_item;
195 DirItem *item = NULL;
196
197 if (i >= 0 && i < collection->number_of_items)
198 item = (DirItem *) collection->items[i].data;
199
200 if (item == NULL || item->leafname[0] != '.')
201 display_set_hidden(filer_window, FALSE);
202 filer_window->temp_show_hidden = FALSE;
203 }
204 }
205
206 /* Insert this leafname at the cursor (replacing the selection, if any).
207 * Must be in SHELL mode.
208 */
209 void minibuffer_add(FilerWindow *filer_window, const gchar *leafname)
210 {
211 guchar *esc;
212 GtkEditable *edit = GTK_EDITABLE(filer_window->minibuffer);
213 GtkEntry *entry = GTK_ENTRY(edit);
214 int pos;
215
216 g_return_if_fail(filer_window->mini_type == MINI_SHELL);
217
218 esc = shell_escape(leafname);
219
220 gtk_editable_delete_selection(edit);
221 pos = gtk_editable_get_position(edit);
222
223 if (pos > 0 && gtk_entry_get_text(entry)[pos - 1] != ' ')
224 gtk_editable_insert_text(edit, " ", 1, &pos);
225
226 gtk_editable_insert_text(edit, esc, strlen(esc), &pos);
227 gtk_editable_set_position(edit, pos);
228
229 g_free(esc);
230 }
231
232
233 /****************************************************************
234 * INTERNAL FUNCTIONS *
235 ****************************************************************/
236
237 static void show_help(FilerWindow *filer_window)
238 {
239 const gchar *message;
240
241 gtk_widget_grab_focus(filer_window->minibuffer);
242
243 switch (filer_window->mini_type)
244 {
245 case MINI_PATH:
246 message = _("Enter the name of a file and I'll display "
247 "it for you. Press Tab to fill in the longest "
248 "match. Escape to close the minibuffer.");
249 break;
250 case MINI_SHELL:
251 message = _("Enter a shell command to execute. Click "
252 "on a file to add it to the buffer.");
253 break;
254 case MINI_SELECT_IF:
255 show_condition_help(NULL);
256 return;
257 default:
258 message = "?!?";
259 break;
260 }
261
262 delayed_error("%s", message);
263 }
264
265
266 /* PATH ENTRY */
267
268 static void path_return_pressed(FilerWindow *filer_window, GdkEventKey *event)
269 {
270 Collection *collection = filer_window->collection;
271 int item = collection->cursor_item;
272 const gchar *path, *pattern;
273 int flags = OPEN_FROM_MINI | OPEN_SAME_WINDOW;
274
275 path = gtk_entry_get_text(GTK_ENTRY(filer_window->minibuffer));
276 pattern = strrchr(path, '/');
277 if (pattern)
278 pattern++;
279 else
280 pattern = path;
281
282 if (item == -1 || item >= collection->number_of_items ||
283 !matches(collection, item, pattern))
284 {
285 gdk_beep();
286 return;
287 }
288
289 if ((event->state & GDK_SHIFT_MASK) != 0)
290 flags |= OPEN_SHIFT;
291
292 filer_openitem(filer_window, item, flags);
293 }
294
295 /* Use the cursor item to fill in the minibuffer.
296 * If there are multiple matches then fill in as much as possible and
297 * (possibly) beep.
298 */
299 static void complete(FilerWindow *filer_window)
300 {
301 GtkEntry *entry;
302 Collection *collection = filer_window->collection;
303 int cursor = collection->cursor_item;
304 DirItem *item;
305 int shortest_stem = -1;
306 int current_stem;
307 int other;
308 const gchar *text, *leaf;
309
310 if (cursor < 0 || cursor >= collection->number_of_items)
311 {
312 gdk_beep();
313 return;
314 }
315
316 entry = GTK_ENTRY(filer_window->minibuffer);
317
318 item = (DirItem *) collection->items[cursor].data;
319
320 text = gtk_entry_get_text(entry);
321 leaf = strrchr(text, '/');
322 if (!leaf)
323 {
324 gdk_beep();
325 return;
326 }
327
328 leaf++;
329 if (!matches(collection, cursor, leaf))
330 {
331 gdk_beep();
332 return;
333 }
334
335 current_stem = strlen(leaf);
336
337 /* Find the longest other match of this name. It it's longer than
338 * the currently entered text then complete only up to that length.
339 */
340 for (other = 0; other < collection->number_of_items; other++)
341 {
342 DirItem *other_item = (DirItem *) collection->items[other].data;
343 int stem = 0;
344
345 if (other == cursor)
346 continue;
347
348 while (other_item->leafname[stem] && item->leafname[stem])
349 {
350 if (other_item->leafname[stem] != item->leafname[stem])
351 break;
352 stem++;
353 }
354
355 /* stem is the index of the first difference */
356 if (stem >= current_stem &&
357 (shortest_stem == -1 || stem < shortest_stem))
358 shortest_stem = stem;
359 }
360
361 if (current_stem == shortest_stem)
362 {
363 /* We didn't add anything... */
364 if (o_filer_beep_fail.int_value)
365 gdk_beep();
366 }
367 else if (current_stem < shortest_stem)
368 {
369 guchar *extra;
370 gint tmp_pos;
371
372 extra = g_strndup(item->leafname + current_stem,
373 shortest_stem - current_stem);
374
375 tmp_pos = entry->text_length;
376 gtk_editable_insert_text(GTK_EDITABLE(entry), extra, -1,
377 &tmp_pos);
378
379 g_free(extra);
380 gtk_editable_set_position(GTK_EDITABLE(entry), -1);
381
382 if (o_filer_beep_multi.int_value)
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 gtk_editable_set_position(GTK_EDITABLE(entry), -1);
397 }
398 }
399
400 /* This is an idle function because Gtk+ 2.0 changes text in a entry
401 * with two signals; one to blank it and one to put the new text in.
402 */
403 static gboolean path_changed(gpointer data)
404 {
405 FilerWindow *filer_window = (FilerWindow *) data;
406 GtkWidget *mini = filer_window->minibuffer;
407 const char *new, *leaf;
408 char *path, *real;
409
410 new = gtk_entry_get_text(GTK_ENTRY(mini));
411
412 leaf = g_basename(new);
413 if (leaf == new)
414 path = g_strdup("/");
415 else
416 path = g_dirname(new);
417 real = pathdup(path);
418 g_free(path);
419
420 if (strcmp(real, filer_window->path) != 0)
421 {
422 /* The new path is in a different directory */
423 struct stat info;
424
425 if (mc_stat(real, &info) == 0 && S_ISDIR(info.st_mode))
426 filer_change_to(filer_window, real, leaf);
427 else
428 gdk_beep();
429 }
430 else
431 {
432 if (*leaf == '.')
433 {
434 if (!filer_window->show_hidden)
435 {
436 filer_window->temp_show_hidden = TRUE;
437 display_set_hidden(filer_window, TRUE);
438 }
439 }
440 else if (filer_window->temp_show_hidden)
441 {
442 display_set_hidden(filer_window, FALSE);
443 filer_window->temp_show_hidden = FALSE;
444 }
445
446 if (find_exact_match(filer_window, leaf) == FALSE &&
447 find_next_match(filer_window, leaf, 0) == FALSE)
448 gdk_beep();
449 }
450
451 g_free(real);
452
453 return FALSE;
454 }
455
456 /* Look for an exact match, and move the cursor to it if found.
457 * TRUE on success.
458 */
459 static gboolean find_exact_match(FilerWindow *filer_window,
460 const gchar *pattern)
461 {
462 Collection *collection = filer_window->collection;
463 int i;
464
465 for (i = 0; i < collection->number_of_items; i++)
466 {
467 DirItem *item = (DirItem *) collection->items[i].data;
468
469 if (strcmp(item->leafname, pattern) == 0)
470 {
471 collection_set_cursor_item(collection, i);
472 return TRUE;
473 }
474 }
475
476 return FALSE;
477 }
478
479 /* Find the next item in the collection that matches 'pattern'. Start from
480 * mini_cursor_base and loop at either end. dir is 1 for a forward search,
481 * -1 for backwards. 0 means forwards, but may stay the same.
482 *
483 * Does not automatically update mini_cursor_base.
484 *
485 * Returns TRUE if a match is found.
486 */
487 static gboolean find_next_match(FilerWindow *filer_window,
488 const char *pattern,
489 int dir)
490 {
491 Collection *collection = filer_window->collection;
492 int base = filer_window->mini_cursor_base;
493 int item = base;
494 gboolean retval = TRUE;
495
496 if (collection->number_of_items < 1)
497 return FALSE;
498
499 if (base < 0 || base>= collection->number_of_items)
500 filer_window->mini_cursor_base = base = 0;
501
502 do
503 {
504 /* Step to the next item */
505 item += dir;
506
507 if (item >= collection->number_of_items)
508 item = 0;
509 else if (item < 0)
510 item = collection->number_of_items - 1;
511
512 if (dir == 0)
513 dir = 1;
514 else if (item == base)
515 {
516 retval = FALSE;
517 break; /* No (other) matches at all */
518 }
519 } while (!matches(collection, item, pattern));
520
521 collection_set_cursor_item(collection, item);
522
523 return retval;
524 }
525
526 static gboolean matches(Collection *collection,
527 int item_number, const 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 const 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(const gchar *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 const gchar *entry;
619 int i;
620 gchar 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 const gchar *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, (gchar *) 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 /* XXX: Use spawn */
738
739 child = fork();
740
741 switch (child)
742 {
743 case -1:
744 delayed_error(_("Failed to create child process"));
745 break;
746 case 0: /* Child */
747 /* Ensure output is noticed - send stdout to stderr */
748 dup2(STDERR_FILENO, STDOUT_FILENO);
749 close_on_exec(STDOUT_FILENO, FALSE);
750 if (chdir(filer_window->path))
751 g_printerr("chdir(%s) failed: %s\n",
752 filer_window->path,
753 g_strerror(errno));
754 execvp((char *) argv->pdata[0],
755 (char **) argv->pdata);
756 g_printerr("execvp(%s, ...) failed: %s\n",
757 (char *) argv->pdata[0],
758 g_strerror(errno));
759 _exit(0);
760 default:
761 on_child_death(child,
762 (CallbackFn) shell_done, filer_window);
763 break;
764 }
765
766 g_ptr_array_free(argv, TRUE);
767
768 out:
769 minibuffer_hide(filer_window);
770 }
771
772 /* Move through the shell history */
773 static void shell_recall(FilerWindow *filer_window, int dir)
774 {
775 guchar *command;
776 int pos = filer_window->mini_cursor_base;
777
778 pos += dir;
779 if (pos >= 0)
780 {
781 command = g_list_nth_data(shell_history, pos);
782 if (!command)
783 return;
784 }
785 else
786 command = "";
787
788 if (pos < -1)
789 pos = -1;
790 filer_window->mini_cursor_base = pos;
791
792 gtk_entry_set_text(GTK_ENTRY(filer_window->minibuffer), command);
793 }
794
795 /* SELECT IF */
796
797 static void select_return_pressed(FilerWindow *filer_window, guint etime)
798 {
799 FindCondition *cond;
800 int i, n;
801 const gchar *entry;
802 Collection *collection = filer_window->collection;
803 FindInfo info;
804
805 entry = mini_contents(filer_window);
806
807 if (!entry)
808 goto out;
809
810 add_to_history(entry);
811
812 cond = find_compile(entry);
813 if (!cond)
814 {
815 delayed_error(_("Invalid Find condition"));
816 return;
817 }
818
819 info.now = time(NULL);
820 info.prune = FALSE; /* (don't care) */
821 n = collection->number_of_items;
822
823 collection->block_selection_changed++;
824
825 /* If an item at the start is selected then we could lose the
826 * primary selection after checking that item and then need to
827 * gain it again at the end. Therefore, if anything is selected
828 * then select the last item until the end of the search.
829 */
830 if (collection->number_selected)
831 collection_select_item(collection, n - 1);
832
833 for (i = 0; i < n; i++)
834 {
835 DirItem *item = (DirItem *) collection->items[i].data;
836
837 info.leaf = item->leafname;
838 info.fullpath = make_path(filer_window->path, info.leaf)->str;
839
840 if (lstat(info.fullpath, &info.stats) == 0 &&
841 find_test_condition(cond, &info))
842 collection_select_item(collection, i);
843 else
844 collection_unselect_item(collection, i);
845 }
846
847 find_condition_free(cond);
848
849 collection_unblock_selection_changed(collection, etime, TRUE);
850 out:
851 minibuffer_hide(filer_window);
852 }
853
854
855 /* EVENT HANDLERS */
856
857 static gint key_press_event(GtkWidget *widget,
858 GdkEventKey *event,
859 FilerWindow *filer_window)
860 {
861 if (event->keyval == GDK_Escape)
862 {
863 if (filer_window->mini_type == MINI_SHELL)
864 {
865 const gchar *line;
866
867 line = mini_contents(filer_window);
868 if (line)
869 add_to_history(line);
870 }
871
872 minibuffer_hide(filer_window);
873 return TRUE;
874 }
875
876 switch (filer_window->mini_type)
877 {
878 case MINI_PATH:
879 switch (event->keyval)
880 {
881 case GDK_Up:
882 search_in_dir(filer_window, -1);
883 break;
884 case GDK_Down:
885 search_in_dir(filer_window, 1);
886 break;
887 case GDK_Return:
888 case GDK_KP_Enter:
889 path_return_pressed(filer_window,
890 event);
891 break;
892 case GDK_Tab:
893 complete(filer_window);
894 break;
895 default:
896 return FALSE;
897 }
898 break;
899
900 case MINI_SHELL:
901 switch (event->keyval)
902 {
903 case GDK_Up:
904 shell_recall(filer_window, 1);
905 break;
906 case GDK_Down:
907 shell_recall(filer_window, -1);
908 break;
909 case GDK_Tab:
910 shell_tab(filer_window);
911 break;
912 case GDK_Return:
913 case GDK_KP_Enter:
914 shell_return_pressed(filer_window);
915 break;
916 default:
917 return FALSE;
918 }
919 break;
920 case MINI_SELECT_IF:
921 switch (event->keyval)
922 {
923 case GDK_Up:
924 shell_recall(filer_window, 1);
925 break;
926 case GDK_Down:
927 shell_recall(filer_window, -1);
928 break;
929 case GDK_Tab:
930 break;
931 case GDK_Return:
932 case GDK_KP_Enter:
933 select_return_pressed(filer_window,
934 event->time);
935 break;
936 default:
937 return FALSE;
938 }
939 break;
940 default:
941 break;
942 }
943
944 return TRUE;
945 }
946
947 static void changed(GtkEditable *mini, FilerWindow *filer_window)
948 {
949 switch (filer_window->mini_type)
950 {
951 case MINI_PATH:
952 gtk_idle_add(path_changed, filer_window);
953 return;
954 case MINI_SELECT_IF:
955 set_find_string_colour(GTK_WIDGET(mini),
956 gtk_entry_get_text(
957 GTK_ENTRY(filer_window->minibuffer)));
958 return;
959 default:
960 break;
961 }
962 }
963
964 /* Returns a string (which must NOT be freed), or NULL if the buffer
965 * is blank (whitespace only).
966 */
967 static const gchar *mini_contents(FilerWindow *filer_window)
968 {
969 const gchar *entry, *c;
970
971 entry = gtk_entry_get_text(GTK_ENTRY(filer_window->minibuffer));
972
973 for (c = entry; *c; c++)
974 if (!isspace(*c))
975 return entry;
976
977 return NULL;
978 }
979
980 /* This is a really ugly hack to get around Gtk+-2.0's broken auto-select
981 * behaviour.
982 */
983 static gboolean grab_focus(GtkWidget *minibuffer)
984 {
985 GtkWidgetClass *class;
986
987 class = GTK_WIDGET_CLASS(gtk_type_class(GTK_TYPE_WIDGET));
988
989 class->grab_focus(minibuffer);
990
991 g_signal_stop_emission(minibuffer,
992 g_signal_lookup("grab_focus", G_OBJECT_TYPE(minibuffer)), 0);
993
994
995 return 1;
996 }
Filer for the ROX desktop