1/*
2 *  $Id: fselect.c,v 1.102 2018/06/21 23:28:04 tom Exp $
3 *
4 *  fselect.c -- implements the file-selector box
5 *
6 *  Copyright 2000-2017,2018	Thomas E. Dickey
7 *
8 *  This program is free software; you can redistribute it and/or modify
9 *  it under the terms of the GNU Lesser General Public License, version 2.1
10 *  as published by the Free Software Foundation.
11 *
12 *  This program is distributed in the hope that it will be useful, but
13 *  WITHOUT ANY WARRANTY; without even the implied warranty of
14 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 *  Lesser General Public License for more details.
16 *
17 *  You should have received a copy of the GNU Lesser General Public
18 *  License along with this program; if not, write to
19 *	Free Software Foundation, Inc.
20 *	51 Franklin St., Fifth Floor
21 *	Boston, MA 02110, USA.
22 */
23
24#include <dialog.h>
25#include <dlg_keys.h>
26
27#include <sys/types.h>
28#include <sys/stat.h>
29
30#if HAVE_DIRENT_H
31# include <dirent.h>
32# define NAMLEN(dirent) strlen((dirent)->d_name)
33#else
34# define dirent direct
35# define NAMLEN(dirent) (dirent)->d_namlen
36# if HAVE_SYS_NDIR_H
37#  include <sys/ndir.h>
38# endif
39# if HAVE_SYS_DIR_H
40#  include <sys/dir.h>
41# endif
42# if HAVE_NDIR_H
43#  include <ndir.h>
44# endif
45#endif
46
47# if defined(_FILE_OFFSET_BITS) && defined(HAVE_STRUCT_DIRENT64)
48#  if !defined(_LP64) && (_FILE_OFFSET_BITS == 64)
49#   define      DIRENT  struct dirent64
50#  else
51#   define      DIRENT  struct dirent
52#  endif
53# else
54#  define       DIRENT  struct dirent
55# endif
56
57#define EXT_WIDE 1
58#define HDR_HIGH 1
59#define BTN_HIGH (1 + 2 * MARGIN)	/* Ok/Cancel, also input-box */
60#define MIN_HIGH (HDR_HIGH - MARGIN + (BTN_HIGH * 2) + 4 * MARGIN)
61#define MIN_WIDE (2 * MAX(dlg_count_columns(d_label), dlg_count_columns(f_label)) + 6 * MARGIN + 2 * EXT_WIDE)
62
63#define MOUSE_D (KEY_MAX + 0)
64#define MOUSE_F (KEY_MAX + 10000)
65#define MOUSE_T (KEY_MAX + 20000)
66
67typedef enum {
68    sDIRS = -3
69    ,sFILES = -2
70    ,sTEXT = -1
71} STATES;
72
73typedef struct {
74    WINDOW *par;		/* parent window */
75    WINDOW *win;		/* this window */
76    int length;			/* length of the data[] array */
77    int offset;			/* index of first item on screen */
78    int choice;			/* index of the selection */
79    int mousex;			/* base of mouse-code return-values */
80    unsigned allocd;
81    char **data;
82} LIST;
83
84typedef struct {
85    int length;
86    char **data;
87} MATCH;
88
89static void
90init_list(LIST * list, WINDOW *par, WINDOW *win, int mousex)
91{
92    list->par = par;
93    list->win = win;
94    list->length = 0;
95    list->offset = 0;
96    list->choice = 0;
97    list->mousex = mousex;
98    list->allocd = 0;
99    list->data = 0;
100    dlg_mouse_mkbigregion(getbegy(win), getbegx(win),
101			  getmaxy(win), getmaxx(win),
102			  mousex, 1, 1, 1 /* by lines */ );
103}
104
105static char *
106leaf_of(char *path)
107{
108    char *leaf = strrchr(path, '/');
109    if (leaf != 0)
110	leaf++;
111    else
112	leaf = path;
113    return leaf;
114}
115
116static char *
117data_of(LIST * list)
118{
119    if (list != 0
120	&& list->data != 0)
121	return list->data[list->choice];
122    return 0;
123}
124
125static void
126free_list(LIST * list, int reinit)
127{
128    int n;
129
130    if (list->data != 0) {
131	for (n = 0; list->data[n] != 0; n++)
132	    free(list->data[n]);
133	free(list->data);
134	list->data = 0;
135    }
136    if (reinit)
137	init_list(list, list->par, list->win, list->mousex);
138}
139
140static void
141add_to_list(LIST * list, char *text)
142{
143    unsigned need;
144
145    need = (unsigned) (list->length + 1);
146    if (need + 1 > list->allocd) {
147	list->allocd = 2 * (need + 1);
148	if (list->data == 0) {
149	    list->data = dlg_malloc(char *, list->allocd);
150	} else {
151	    list->data = dlg_realloc(char *, list->allocd, list->data);
152	}
153	assert_ptr(list->data, "add_to_list");
154    }
155    list->data[list->length++] = dlg_strclone(text);
156    list->data[list->length] = 0;
157}
158
159static void
160keep_visible(LIST * list)
161{
162    int high = getmaxy(list->win);
163
164    if (list->choice < list->offset) {
165	list->offset = list->choice;
166    }
167    if (list->choice - list->offset >= high)
168	list->offset = list->choice - high + 1;
169}
170
171#define Value(c) (int)((c) & 0xff)
172
173static int
174find_choice(char *target, LIST * list)
175{
176    int n;
177    int choice = list->choice;
178    int len_1, len_2, cmp_1, cmp_2;
179
180    if (*target == 0) {
181	list->choice = 0;
182    } else {
183	/* find the match with the longest length.  If more than one has the
184	 * same length, choose the one with the closest match of the final
185	 * character.
186	 */
187	len_1 = 0;
188	cmp_1 = 256;
189	for (n = 0; n < list->length; n++) {
190	    char *a = target;
191	    char *b = list->data[n];
192
193	    len_2 = 0;
194	    while ((*a != 0) && (*b != 0) && (*a == *b)) {
195		a++;
196		b++;
197		len_2++;
198	    }
199	    cmp_2 = Value(*a) - Value(*b);
200	    if (cmp_2 < 0)
201		cmp_2 = -cmp_2;
202	    if ((len_2 > len_1)
203		|| (len_1 == len_2 && cmp_2 < cmp_1)) {
204		len_1 = len_2;
205		cmp_1 = cmp_2;
206		list->choice = n;
207	    }
208	}
209    }
210    if (choice != list->choice) {
211	keep_visible(list);
212    }
213    return (choice != list->choice);
214}
215
216static void
217display_list(LIST * list)
218{
219    int n;
220    int x;
221    int y;
222    int top;
223    int bottom;
224
225    if (list->win != 0) {
226	dlg_attr_clear(list->win, getmaxy(list->win), getmaxx(list->win), item_attr);
227	for (n = list->offset; n < list->length && list->data[n]; n++) {
228	    y = n - list->offset;
229	    if (y >= getmaxy(list->win))
230		break;
231	    (void) wmove(list->win, y, 0);
232	    if (n == list->choice)
233		dlg_attrset(list->win, item_selected_attr);
234	    (void) waddstr(list->win, list->data[n]);
235	    dlg_attrset(list->win, item_attr);
236	}
237	dlg_attrset(list->win, item_attr);
238
239	getparyx(list->win, y, x);
240
241	top = y - 1;
242	bottom = y + getmaxy(list->win);
243	dlg_draw_scrollbar(list->par,
244			   (long) list->offset,
245			   (long) list->offset,
246			   (long) (list->offset + getmaxy(list->win)),
247			   (long) (list->length),
248			   x + 1,
249			   x + getmaxx(list->win),
250			   top,
251			   bottom,
252			   menubox_border2_attr,
253			   menubox_border_attr);
254
255	(void) wmove(list->win, list->choice - list->offset, 0);
256	(void) wnoutrefresh(list->win);
257    }
258}
259
260/* FIXME: see arrows.c
261 * This workaround is used to allow two lists to have scroll-tabs at the same
262 * time, by reassigning their return-values to be different.  Just for
263 * readability, we use the names of keys with similar connotations, though all
264 * that is really required is that they're distinct, so we can put them in a
265 * switch statement.
266 */
267static void
268fix_arrows(LIST * list)
269{
270    int x;
271    int y;
272    int top;
273    int right;
274    int bottom;
275
276    if (list->win != 0) {
277	getparyx(list->win, y, x);
278	top = y - 1;
279	right = getmaxx(list->win);
280	bottom = y + getmaxy(list->win);
281
282	mouse_mkbutton(top, x, right,
283		       ((list->mousex == MOUSE_D)
284			? KEY_PREVIOUS
285			: KEY_PPAGE));
286	mouse_mkbutton(bottom, x, right,
287		       ((list->mousex == MOUSE_D)
288			? KEY_NEXT
289			: KEY_NPAGE));
290    }
291}
292
293static bool
294show_list(char *target, LIST * list, bool keep)
295{
296    bool changed = keep || find_choice(target, list);
297    display_list(list);
298    return changed;
299}
300
301/*
302 * Highlight the closest match to 'target' in the given list, setting offset
303 * to match.
304 */
305static bool
306show_both_lists(char *input, LIST * d_list, LIST * f_list, bool keep)
307{
308    char *leaf = leaf_of(input);
309
310    return show_list(leaf, d_list, keep) || show_list(leaf, f_list, keep);
311}
312
313/*
314 * Move up/down in the given list
315 */
316static bool
317change_list(int choice, LIST * list)
318{
319    if (data_of(list) != 0) {
320	int last = list->length - 1;
321
322	choice += list->choice;
323	if (choice < 0)
324	    choice = 0;
325	if (choice > last)
326	    choice = last;
327	list->choice = choice;
328	keep_visible(list);
329	display_list(list);
330	return TRUE;
331    }
332    return FALSE;
333}
334
335static void
336scroll_list(int direction, LIST * list)
337{
338    if (data_of(list) != 0) {
339	int length = getmaxy(list->win);
340	if (change_list(direction * length, list))
341	    return;
342    }
343    beep();
344}
345
346static int
347compar(const void *a, const void *b)
348{
349    return strcmp(*(const char *const *) a, *(const char *const *) b);
350}
351
352static void
353match(char *name, LIST * d_list, LIST * f_list, MATCH * match_list)
354{
355    char *test = leaf_of(name);
356    size_t test_len = strlen(test);
357    char **matches = dlg_malloc(char *, (size_t) (d_list->length + f_list->length));
358    size_t data_len = 0;
359    int i;
360    for (i = 2; i < d_list->length; i++) {
361	if (strncmp(test, d_list->data[i], test_len) == 0) {
362	    matches[data_len++] = d_list->data[i];
363	}
364    }
365    for (i = 0; i < f_list->length; i++) {
366	if (strncmp(test, f_list->data[i], test_len) == 0) {
367	    matches[data_len++] = f_list->data[i];
368	}
369    }
370    matches = dlg_realloc(char *, data_len + 1, matches);
371    match_list->data = matches;
372    match_list->length = (int) data_len;
373}
374
375static void
376free_match(MATCH * match_list)
377{
378    free(match_list->data);
379    match_list->length = 0;
380}
381
382static int
383complete(char *name, LIST * d_list, LIST * f_list, char **buff_ptr)
384{
385    MATCH match_list;
386    char *test;
387    size_t test_len;
388    size_t i;
389    int j;
390    char *buff;
391
392    match(name, d_list, f_list, &match_list);
393    if (match_list.length == 0) {
394	*buff_ptr = NULL;
395	return 0;
396    }
397
398    test = match_list.data[0];
399    test_len = strlen(test);
400    buff = dlg_malloc(char, test_len + 2);
401    if (match_list.length == 1) {
402	strcpy(buff, test);
403	i = test_len;
404	if (test == data_of(d_list)) {
405	    buff[test_len] = '/';
406	    i++;
407	}
408    } else {
409	for (i = 0; i < test_len; i++) {
410	    char test_char = test[i];
411	    if (test_char == '\0')
412		break;
413	    for (j = 0; j < match_list.length; j++) {
414		if (match_list.data[j][i] != test_char) {
415		    break;
416		}
417	    }
418	    if (j == match_list.length) {
419		(buff)[i] = test_char;
420	    } else
421		break;
422	}
423	buff = dlg_realloc(char, i + 1, buff);
424    }
425    free_match(&match_list);
426    buff[i] = '\0';
427    *buff_ptr = buff;
428    return (i != 0);
429}
430
431static bool
432fill_lists(char *current, char *input, LIST * d_list, LIST * f_list, bool keep)
433{
434    bool result = TRUE;
435    bool rescan = FALSE;
436    DIR *dp;
437    DIRENT *de;
438    struct stat sb;
439    int n;
440    char path[MAX_LEN + 1];
441    char *leaf;
442
443    /* check if we've updated the lists */
444    for (n = 0; current[n] && input[n]; n++) {
445	if (current[n] != input[n])
446	    break;
447    }
448
449    if (current[n] == input[n]) {
450	result = FALSE;
451	rescan = (n == 0 && d_list->length == 0);
452    } else if (strchr(current + n, '/') == 0
453	       && strchr(input + n, '/') == 0) {
454	result = show_both_lists(input, d_list, f_list, keep);
455    } else {
456	rescan = TRUE;
457    }
458
459    if (rescan) {
460	size_t have = strlen(input);
461
462	if (have > MAX_LEN)
463	    have = MAX_LEN;
464	memcpy(current, input, have);
465	current[have] = '\0';
466
467	/* refill the lists */
468	free_list(d_list, TRUE);
469	free_list(f_list, TRUE);
470	memcpy(path, current, have);
471	path[have] = '\0';
472	if ((leaf = strrchr(path, '/')) != 0) {
473	    *++leaf = 0;
474	} else {
475	    strcpy(path, "./");
476	    leaf = path + strlen(path);
477	}
478	DLG_TRACE(("opendir '%s'\n", path));
479	if ((dp = opendir(path)) != 0) {
480	    while ((de = readdir(dp)) != 0) {
481		size_t len = NAMLEN(de);
482		if (len == 0 || (len + have + 2) >= MAX_LEN)
483		    continue;
484		memcpy(leaf, de->d_name, len);
485		leaf[len] = '\0';
486		if (stat(path, &sb) == 0) {
487		    if ((sb.st_mode & S_IFMT) == S_IFDIR)
488			add_to_list(d_list, leaf);
489		    else if (f_list->win)
490			add_to_list(f_list, leaf);
491		}
492	    }
493	    (void) closedir(dp);
494	    /* sort the lists */
495	    if (d_list->data != 0 && d_list->length > 1) {
496		qsort(d_list->data,
497		      (size_t) d_list->length,
498		      sizeof(d_list->data[0]),
499		      compar);
500	    }
501	    if (f_list->data != 0 && f_list->length > 1) {
502		qsort(f_list->data,
503		      (size_t) f_list->length,
504		      sizeof(f_list->data[0]),
505		      compar);
506	    }
507	}
508
509	(void) show_both_lists(input, d_list, f_list, FALSE);
510	d_list->offset = d_list->choice;
511	f_list->offset = f_list->choice;
512	result = TRUE;
513    }
514    return result;
515}
516
517static bool
518usable_state(int state, LIST * dirs, LIST * files)
519{
520    bool result;
521
522    switch (state) {
523    case sDIRS:
524	result = (dirs->win != 0) && (data_of(dirs) != 0);
525	break;
526    case sFILES:
527	result = (files->win != 0) && (data_of(files) != 0);
528	break;
529    default:
530	result = TRUE;
531	break;
532    }
533    return result;
534}
535
536#define which_list() ((state == sFILES) \
537			? &f_list \
538			: ((state == sDIRS) \
539			  ? &d_list \
540			  : 0))
541#define NAVIGATE_BINDINGS \
542	DLG_KEYS_DATA( DLGK_FIELD_NEXT, KEY_RIGHT ), \
543	DLG_KEYS_DATA( DLGK_FIELD_NEXT, TAB ), \
544	DLG_KEYS_DATA( DLGK_FIELD_PREV, KEY_BTAB ), \
545	DLG_KEYS_DATA( DLGK_ITEM_NEXT,  KEY_DOWN ), \
546	DLG_KEYS_DATA( DLGK_ITEM_NEXT,  CHR_NEXT ), \
547	DLG_KEYS_DATA( DLGK_ITEM_NEXT,  KEY_NEXT ), \
548	DLG_KEYS_DATA( DLGK_ITEM_PREV,  CHR_PREVIOUS ), \
549	DLG_KEYS_DATA( DLGK_ITEM_PREV,  KEY_UP ), \
550	DLG_KEYS_DATA( DLGK_PAGE_NEXT,  KEY_NPAGE ), \
551	DLG_KEYS_DATA( DLGK_PAGE_PREV,  KEY_PPAGE )
552
553/*
554 * Display a dialog box for entering a filename
555 */
556static int
557dlg_fselect(const char *title, const char *path, int height, int width, int dselect)
558{
559    /* *INDENT-OFF* */
560    static DLG_KEYS_BINDING binding[] = {
561	HELPKEY_BINDINGS,
562	ENTERKEY_BINDINGS,
563	NAVIGATE_BINDINGS,
564	TOGGLEKEY_BINDINGS,
565	END_KEYS_BINDING
566    };
567    static DLG_KEYS_BINDING binding2[] = {
568	INPUTSTR_BINDINGS,
569	HELPKEY_BINDINGS,
570	ENTERKEY_BINDINGS,
571	NAVIGATE_BINDINGS,
572	TOGGLEKEY_BINDINGS,
573	END_KEYS_BINDING
574    };
575    /* *INDENT-ON* */
576
577#ifdef KEY_RESIZE
578    int old_height = height;
579    int old_width = width;
580    bool resized = FALSE;
581#endif
582    int tbox_y, tbox_x, tbox_width, tbox_height;
583    int dbox_y, dbox_x, dbox_width, dbox_height;
584    int fbox_y, fbox_x, fbox_width, fbox_height;
585    int show_buttons = TRUE;
586    int offset = 0;
587    int key = 0;
588    int fkey = FALSE;
589    int code;
590    int result = DLG_EXIT_UNKNOWN;
591    int state = dialog_vars.default_button >= 0 ? dlg_default_button() : sTEXT;
592    int button;
593    bool first = (state == sTEXT);
594    bool first_trace = TRUE;
595    char *input;
596    char *completed;
597    char current[MAX_LEN + 1];
598    WINDOW *dialog = 0;
599    WINDOW *w_text = 0;
600    WINDOW *w_work = 0;
601    const char **buttons = dlg_ok_labels();
602    const char *d_label = _("Directories");
603    const char *f_label = _("Files");
604    char *partial = 0;
605    int min_wide = MIN_WIDE;
606    int min_items = height ? 0 : 4;
607    LIST d_list, f_list;
608
609    DLG_TRACE(("# %s args:\n", dselect ? "dselect" : "fselect"));
610    DLG_TRACE2S("title", title);
611    DLG_TRACE2S("path", path);
612    DLG_TRACE2N("height", height);
613    DLG_TRACE2N("width", width);
614
615    dlg_does_output();
616
617    /* Set up the initial value */
618    input = dlg_set_result(path);
619    offset = (int) strlen(input);
620    *current = 0;
621
622    dlg_button_layout(buttons, &min_wide);
623
624#ifdef KEY_RESIZE
625  retry:
626#endif
627    dlg_auto_size(title, (char *) 0, &height, &width, 6, 25);
628    height += MIN_HIGH + min_items;
629    if (width < min_wide)
630	width = min_wide;
631    dlg_print_size(height, width);
632    dlg_ctl_size(height, width);
633
634    dialog = dlg_new_window(height, width,
635			    dlg_box_y_ordinate(height),
636			    dlg_box_x_ordinate(width));
637    dlg_register_window(dialog, "fselect", binding);
638    dlg_register_buttons(dialog, "fselect", buttons);
639
640    dlg_mouse_setbase(0, 0);
641
642    dlg_draw_box2(dialog, 0, 0, height, width, dialog_attr, border_attr, border2_attr);
643    dlg_draw_bottom_box2(dialog, border_attr, border2_attr, dialog_attr);
644    dlg_draw_title(dialog, title);
645
646    dlg_attrset(dialog, dialog_attr);
647
648    /* Draw the input field box */
649    tbox_height = 1;
650    tbox_width = width - (4 * MARGIN + 2);
651    tbox_y = height - (BTN_HIGH * 2) + MARGIN;
652    tbox_x = (width - tbox_width) / 2;
653
654    w_text = derwin(dialog, tbox_height, tbox_width, tbox_y, tbox_x);
655    if (w_text == 0) {
656	result = DLG_EXIT_ERROR;
657	goto finish;
658    }
659
660    (void) keypad(w_text, TRUE);
661    dlg_draw_box(dialog, tbox_y - MARGIN, tbox_x - MARGIN,
662		 (2 * MARGIN + 1), tbox_width + (MARGIN + EXT_WIDE),
663		 menubox_border_attr, menubox_border2_attr);
664    dlg_mouse_mkbigregion(getbegy(dialog) + tbox_y - MARGIN,
665			  getbegx(dialog) + tbox_x - MARGIN,
666			  1 + (2 * MARGIN),
667			  tbox_width + (MARGIN + EXT_WIDE),
668			  MOUSE_T, 1, 1, 3 /* doesn't matter */ );
669
670    dlg_register_window(w_text, "fselect2", binding2);
671
672    /* Draw the directory listing box */
673    if (dselect)
674	dbox_width = (width - (6 * MARGIN));
675    else
676	dbox_width = (width - (6 * MARGIN + 2 * EXT_WIDE)) / 2;
677    dbox_height = height - MIN_HIGH;
678    dbox_y = (2 * MARGIN + 1);
679    dbox_x = tbox_x;
680
681    w_work = derwin(dialog, dbox_height, dbox_width, dbox_y, dbox_x);
682    if (w_work == 0) {
683	result = DLG_EXIT_ERROR;
684	goto finish;
685    }
686
687    (void) keypad(w_work, TRUE);
688    (void) mvwaddstr(dialog, dbox_y - (MARGIN + 1), dbox_x - MARGIN, d_label);
689    dlg_draw_box(dialog,
690		 dbox_y - MARGIN, dbox_x - MARGIN,
691		 dbox_height + (MARGIN + 1), dbox_width + (MARGIN + 1),
692		 menubox_border_attr, menubox_border2_attr);
693    init_list(&d_list, dialog, w_work, MOUSE_D);
694
695    if (!dselect) {
696	/* Draw the filename listing box */
697	fbox_height = dbox_height;
698	fbox_width = dbox_width;
699	fbox_y = dbox_y;
700	fbox_x = tbox_x + dbox_width + (2 * MARGIN);
701
702	w_work = derwin(dialog, fbox_height, fbox_width, fbox_y, fbox_x);
703	if (w_work == 0) {
704	    result = DLG_EXIT_ERROR;
705	    goto finish;
706	}
707
708	(void) keypad(w_work, TRUE);
709	(void) mvwaddstr(dialog, fbox_y - (MARGIN + 1), fbox_x - MARGIN, f_label);
710	dlg_draw_box(dialog,
711		     fbox_y - MARGIN, fbox_x - MARGIN,
712		     fbox_height + (MARGIN + 1), fbox_width + (MARGIN + 1),
713		     menubox_border_attr, menubox_border2_attr);
714	init_list(&f_list, dialog, w_work, MOUSE_F);
715    } else {
716	memset(&f_list, 0, sizeof(f_list));
717    }
718
719    while (result == DLG_EXIT_UNKNOWN) {
720
721	if (fill_lists(current, input, &d_list, &f_list, state < sTEXT))
722	    show_buttons = TRUE;
723
724#ifdef KEY_RESIZE
725	if (resized) {
726	    resized = FALSE;
727	    dlg_show_string(w_text, input, offset, inputbox_attr,
728			    0, 0, tbox_width, FALSE, first);
729	}
730#endif
731
732	/*
733	 * The last field drawn determines where the cursor is shown:
734	 */
735	if (show_buttons) {
736	    show_buttons = FALSE;
737	    button = (state < 0) ? 0 : state;
738	    dlg_draw_buttons(dialog, height - 2, 0, buttons, button, FALSE, width);
739	}
740
741	if (first_trace) {
742	    first_trace = FALSE;
743	    dlg_trace_win(dialog);
744	}
745
746	if (state < 0) {
747	    switch (state) {
748	    case sTEXT:
749		dlg_set_focus(dialog, w_text);
750		break;
751	    case sFILES:
752		dlg_set_focus(dialog, f_list.win);
753		break;
754	    case sDIRS:
755		dlg_set_focus(dialog, d_list.win);
756		break;
757	    }
758	}
759
760	if (first) {
761	    (void) wrefresh(dialog);
762	} else {
763	    fix_arrows(&d_list);
764	    fix_arrows(&f_list);
765	    key = dlg_mouse_wgetch((state == sTEXT) ? w_text : dialog, &fkey);
766	    if (dlg_result_key(key, fkey, &result))
767		break;
768	}
769
770	if (key == DLGK_TOGGLE) {
771	    key = DLGK_SELECT;
772	    fkey = TRUE;
773	}
774
775	if (fkey) {
776	    switch (key) {
777	    case DLGK_MOUSE(KEY_PREVIOUS):
778		state = sDIRS;
779		scroll_list(-1, which_list());
780		continue;
781	    case DLGK_MOUSE(KEY_NEXT):
782		state = sDIRS;
783		scroll_list(1, which_list());
784		continue;
785	    case DLGK_MOUSE(KEY_PPAGE):
786		state = sFILES;
787		scroll_list(-1, which_list());
788		continue;
789	    case DLGK_MOUSE(KEY_NPAGE):
790		state = sFILES;
791		scroll_list(1, which_list());
792		continue;
793	    case DLGK_PAGE_PREV:
794		scroll_list(-1, which_list());
795		continue;
796	    case DLGK_PAGE_NEXT:
797		scroll_list(1, which_list());
798		continue;
799	    case DLGK_ITEM_PREV:
800		if (change_list(-1, which_list()))
801		    continue;
802		/* FALLTHRU */
803	    case DLGK_FIELD_PREV:
804		show_buttons = TRUE;
805		do {
806		    state = dlg_prev_ok_buttonindex(state, sDIRS);
807		} while (!usable_state(state, &d_list, &f_list));
808		continue;
809	    case DLGK_ITEM_NEXT:
810		if (change_list(1, which_list()))
811		    continue;
812		/* FALLTHRU */
813	    case DLGK_FIELD_NEXT:
814		show_buttons = TRUE;
815		do {
816		    state = dlg_next_ok_buttonindex(state, sDIRS);
817		} while (!usable_state(state, &d_list, &f_list));
818		continue;
819	    case DLGK_SELECT:
820		completed = 0;
821		if (partial != 0) {
822		    free(partial);
823		    partial = 0;
824		}
825		if (state == sFILES && !dselect) {
826		    completed = data_of(&f_list);
827		} else if (state == sDIRS) {
828		    completed = data_of(&d_list);
829		} else {
830		    if (complete(input, &d_list, &f_list, &partial)) {
831			completed = partial;
832		    }
833		}
834		if (completed != 0) {
835		    state = sTEXT;
836		    show_buttons = TRUE;
837		    strcpy(leaf_of(input), completed);
838		    offset = (int) strlen(input);
839		    dlg_show_string(w_text, input, offset, inputbox_attr,
840				    0, 0, tbox_width, 0, first);
841		    if (partial != NULL) {
842			free(partial);
843			partial = 0;
844		    }
845		    continue;
846		} else {	/* if (state < sTEXT) */
847		    (void) beep();
848		    continue;
849		}
850		/* FALLTHRU */
851	    case DLGK_ENTER:
852		result = (state > 0) ? dlg_enter_buttoncode(state) : DLG_EXIT_OK;
853		continue;
854#ifdef KEY_RESIZE
855	    case KEY_RESIZE:
856		dlg_will_resize(dialog);
857		/* reset data */
858		height = old_height;
859		width = old_width;
860		show_buttons = TRUE;
861		*current = 0;
862		resized = TRUE;
863		/* repaint */
864		dlg_clear();
865		dlg_del_window(dialog);
866		refresh();
867		dlg_mouse_free_regions();
868		goto retry;
869#endif
870	    default:
871		if (key >= DLGK_MOUSE(MOUSE_T)) {
872		    state = sTEXT;
873		    continue;
874		} else if (key >= DLGK_MOUSE(MOUSE_F)) {
875		    if (f_list.win != 0) {
876			state = sFILES;
877			f_list.choice = (key - DLGK_MOUSE(MOUSE_F)) + f_list.offset;
878			display_list(&f_list);
879		    }
880		    continue;
881		} else if (key >= DLGK_MOUSE(MOUSE_D)) {
882		    if (d_list.win != 0) {
883			state = sDIRS;
884			d_list.choice = (key - DLGK_MOUSE(MOUSE_D)) + d_list.offset;
885			display_list(&d_list);
886		    }
887		    continue;
888		} else if (is_DLGK_MOUSE(key)
889			   && (code = dlg_ok_buttoncode(key - M_EVENT)) >= 0) {
890		    result = code;
891		    continue;
892		}
893		break;
894	    }
895	}
896
897	if (state < 0) {	/* Input box selected if we're editing */
898	    int edit = dlg_edit_string(input, &offset, key, fkey, first);
899
900	    if (edit) {
901		dlg_show_string(w_text, input, offset, inputbox_attr,
902				0, 0, tbox_width, 0, first);
903		first = FALSE;
904		state = sTEXT;
905	    }
906	} else if (state >= 0 &&
907		   (code = dlg_char_to_button(key, buttons)) >= 0) {
908	    result = dlg_ok_buttoncode(code);
909	    break;
910	}
911    }
912
913    dlg_unregister_window(w_text);
914    dlg_del_window(dialog);
915    dlg_mouse_free_regions();
916    free_list(&d_list, FALSE);
917    free_list(&f_list, FALSE);
918
919  finish:
920    if (partial != 0)
921	free(partial);
922    return result;
923}
924
925/*
926 * Display a dialog box for entering a filename
927 */
928int
929dialog_fselect(const char *title, const char *path, int height, int width)
930{
931    return dlg_fselect(title, path, height, width, FALSE);
932}
933
934/*
935 * Display a dialog box for entering a directory
936 */
937int
938dialog_dselect(const char *title, const char *path, int height, int width)
939{
940    return dlg_fselect(title, path, height, width, TRUE);
941}
942