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
67 typedef enum {
68 sDIRS = -3
69 ,sFILES = -2
70 ,sTEXT = -1
71 } STATES;
72
73 typedef 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
84 typedef struct {
85 int length;
86 char **data;
87 } MATCH;
88
89 static void
init_list(LIST * list,WINDOW * par,WINDOW * win,int mousex)90 init_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
105 static char *
leaf_of(char * path)106 leaf_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
116 static char *
data_of(LIST * list)117 data_of(LIST * list)
118 {
119 if (list != 0
120 && list->data != 0)
121 return list->data[list->choice];
122 return 0;
123 }
124
125 static void
free_list(LIST * list,int reinit)126 free_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
140 static void
add_to_list(LIST * list,char * text)141 add_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
159 static void
keep_visible(LIST * list)160 keep_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
173 static int
find_choice(char * target,LIST * list)174 find_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
216 static void
display_list(LIST * list)217 display_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 */
267 static void
fix_arrows(LIST * list)268 fix_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
293 static bool
show_list(char * target,LIST * list,bool keep)294 show_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 */
305 static bool
show_both_lists(char * input,LIST * d_list,LIST * f_list,bool keep)306 show_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 */
316 static bool
change_list(int choice,LIST * list)317 change_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
335 static void
scroll_list(int direction,LIST * list)336 scroll_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
346 static int
compar(const void * a,const void * b)347 compar(const void *a, const void *b)
348 {
349 return strcmp(*(const char *const *) a, *(const char *const *) b);
350 }
351
352 static void
match(char * name,LIST * d_list,LIST * f_list,MATCH * match_list)353 match(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
375 static void
free_match(MATCH * match_list)376 free_match(MATCH * match_list)
377 {
378 free(match_list->data);
379 match_list->length = 0;
380 }
381
382 static int
complete(char * name,LIST * d_list,LIST * f_list,char ** buff_ptr)383 complete(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
431 static bool
fill_lists(char * current,char * input,LIST * d_list,LIST * f_list,bool keep)432 fill_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
517 static bool
usable_state(int state,LIST * dirs,LIST * files)518 usable_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 */
556 static int
dlg_fselect(const char * title,const char * path,int height,int width,int dselect)557 dlg_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 */
928 int
dialog_fselect(const char * title,const char * path,int height,int width)929 dialog_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 */
937 int
dialog_dselect(const char * title,const char * path,int height,int width)938 dialog_dselect(const char *title, const char *path, int height, int width)
939 {
940 return dlg_fselect(title, path, height, width, TRUE);
941 }
942