1 /* 2 * $Id: fselect.c,v 1.111 2020/03/27 20:58:52 tom Exp $ 3 * 4 * fselect.c -- implements the file-selector box 5 * 6 * Copyright 2000-2019,2020 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 <dlg_internals.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 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 * 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 * 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 126 free_list(LIST * list, int reinit) 127 { 128 if (list->data != 0) { 129 int n; 130 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 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 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 174 find_choice(char *target, LIST * list) 175 { 176 int choice = list->choice; 177 178 if (*target == 0) { 179 list->choice = 0; 180 } else { 181 int n; 182 int len_1, cmp_1; 183 184 /* find the match with the longest length. If more than one has the 185 * same length, choose the one with the closest match of the final 186 * character. 187 */ 188 len_1 = 0; 189 cmp_1 = 256; 190 for (n = 0; n < list->length; n++) { 191 char *a = target; 192 char *b = list->data[n]; 193 int len_2, cmp_2; 194 195 len_2 = 0; 196 while ((*a != 0) && (*b != 0) && (*a == *b)) { 197 a++; 198 b++; 199 len_2++; 200 } 201 cmp_2 = Value(*a) - Value(*b); 202 if (cmp_2 < 0) 203 cmp_2 = -cmp_2; 204 if ((len_2 > len_1) 205 || (len_1 == len_2 && cmp_2 < cmp_1)) { 206 len_1 = len_2; 207 cmp_1 = cmp_2; 208 list->choice = n; 209 } 210 } 211 } 212 if (choice != list->choice) { 213 keep_visible(list); 214 } 215 return (choice != list->choice); 216 } 217 218 static void 219 display_list(LIST * list) 220 { 221 if (list->win != 0) { 222 int n; 223 int x; 224 int y; 225 int top; 226 int bottom; 227 228 dlg_attr_clear(list->win, getmaxy(list->win), getmaxx(list->win), item_attr); 229 for (n = list->offset; n < list->length && list->data[n]; n++) { 230 y = n - list->offset; 231 if (y >= getmaxy(list->win)) 232 break; 233 (void) wmove(list->win, y, 0); 234 if (n == list->choice) 235 dlg_attrset(list->win, item_selected_attr); 236 (void) waddstr(list->win, list->data[n]); 237 dlg_attrset(list->win, item_attr); 238 } 239 dlg_attrset(list->win, item_attr); 240 241 getparyx(list->win, y, x); 242 243 top = y - 1; 244 bottom = y + getmaxy(list->win); 245 dlg_draw_scrollbar(list->par, 246 (long) list->offset, 247 (long) list->offset, 248 (long) (list->offset + getmaxy(list->win)), 249 (long) (list->length), 250 x + 1, 251 x + getmaxx(list->win), 252 top, 253 bottom, 254 menubox_border2_attr, 255 menubox_border_attr); 256 257 (void) wmove(list->win, list->choice - list->offset, 0); 258 (void) wnoutrefresh(list->win); 259 } 260 } 261 262 /* FIXME: see arrows.c 263 * This workaround is used to allow two lists to have scroll-tabs at the same 264 * time, by reassigning their return-values to be different. Just for 265 * readability, we use the names of keys with similar connotations, though all 266 * that is really required is that they're distinct, so we can put them in a 267 * switch statement. 268 */ 269 #if USE_MOUSE 270 static void 271 fix_arrows(LIST * list) 272 { 273 if (list->win != 0) { 274 int x; 275 int y; 276 int top; 277 int right; 278 int bottom; 279 280 getparyx(list->win, y, x); 281 top = y - 1; 282 right = getmaxx(list->win); 283 bottom = y + getmaxy(list->win); 284 285 mouse_mkbutton(top, x, right, 286 ((list->mousex == MOUSE_D) 287 ? KEY_PREVIOUS 288 : KEY_PPAGE)); 289 mouse_mkbutton(bottom, x, right, 290 ((list->mousex == MOUSE_D) 291 ? KEY_NEXT 292 : KEY_NPAGE)); 293 } 294 } 295 #else 296 #define fix_arrows(list) /* nothing */ 297 #endif 298 299 static bool 300 show_list(char *target, LIST * list, bool keep) 301 { 302 bool changed = keep || find_choice(target, list); 303 display_list(list); 304 return changed; 305 } 306 307 /* 308 * Highlight the closest match to 'target' in the given list, setting offset 309 * to match. 310 */ 311 static bool 312 show_both_lists(char *input, LIST * d_list, LIST * f_list, bool keep) 313 { 314 char *leaf = leaf_of(input); 315 316 return show_list(leaf, d_list, keep) || show_list(leaf, f_list, keep); 317 } 318 319 /* 320 * Move up/down in the given list 321 */ 322 static bool 323 change_list(int choice, LIST * list) 324 { 325 if (data_of(list) != 0) { 326 int last = list->length - 1; 327 328 choice += list->choice; 329 if (choice < 0) 330 choice = 0; 331 if (choice > last) 332 choice = last; 333 list->choice = choice; 334 keep_visible(list); 335 display_list(list); 336 return TRUE; 337 } 338 return FALSE; 339 } 340 341 static void 342 scroll_list(int direction, LIST * list) 343 { 344 if (data_of(list) != 0) { 345 int length = getmaxy(list->win); 346 if (change_list(direction * length, list)) 347 return; 348 } 349 beep(); 350 } 351 352 static int 353 compar(const void *a, const void *b) 354 { 355 return strcmp(*(const char *const *) a, *(const char *const *) b); 356 } 357 358 static void 359 match(char *name, LIST * d_list, LIST * f_list, MATCH * match_list) 360 { 361 char *test = leaf_of(name); 362 size_t test_len = strlen(test); 363 char **matches = dlg_malloc(char *, (size_t) (d_list->length + f_list->length)); 364 size_t data_len = 0; 365 366 if (matches != 0) { 367 int i; 368 char **new_ptr; 369 370 for (i = 2; i < d_list->length; i++) { 371 if (strncmp(test, d_list->data[i], test_len) == 0) { 372 matches[data_len++] = d_list->data[i]; 373 } 374 } 375 for (i = 0; i < f_list->length; i++) { 376 if (strncmp(test, f_list->data[i], test_len) == 0) { 377 matches[data_len++] = f_list->data[i]; 378 } 379 } 380 if ((new_ptr = dlg_realloc(char *, data_len + 1, matches)) != 0) { 381 matches = new_ptr; 382 } else { 383 free(matches); 384 matches = 0; 385 data_len = 0; 386 } 387 } 388 match_list->data = matches; 389 match_list->length = (int) data_len; 390 } 391 392 static void 393 free_match(MATCH * match_list) 394 { 395 free(match_list->data); 396 match_list->length = 0; 397 } 398 399 static int 400 complete(char *name, LIST * d_list, LIST * f_list, char **buff_ptr) 401 { 402 MATCH match_list; 403 char *test; 404 size_t test_len; 405 size_t i; 406 char *buff; 407 408 match(name, d_list, f_list, &match_list); 409 if (match_list.length == 0) { 410 *buff_ptr = NULL; 411 return 0; 412 } 413 414 test = match_list.data[0]; 415 test_len = strlen(test); 416 buff = dlg_malloc(char, test_len + 2); 417 if (match_list.length == 1) { 418 strcpy(buff, test); 419 i = test_len; 420 if (test == data_of(d_list)) { 421 buff[test_len] = '/'; 422 i++; 423 } 424 } else { 425 int j; 426 427 for (i = 0; i < test_len; i++) { 428 char test_char = test[i]; 429 if (test_char == '\0') 430 break; 431 for (j = 0; j < match_list.length; j++) { 432 if (match_list.data[j][i] != test_char) { 433 break; 434 } 435 } 436 if (j == match_list.length) { 437 (buff)[i] = test_char; 438 } else 439 break; 440 } 441 buff = dlg_realloc(char, i + 1, buff); 442 } 443 free_match(&match_list); 444 buff[i] = '\0'; 445 *buff_ptr = buff; 446 return (i != 0); 447 } 448 449 static bool 450 fill_lists(char *current, char *input, LIST * d_list, LIST * f_list, bool keep) 451 { 452 bool result = TRUE; 453 bool rescan = FALSE; 454 struct stat sb; 455 int n; 456 char path[MAX_LEN + 1]; 457 458 /* check if we've updated the lists */ 459 for (n = 0; current[n] && input[n]; n++) { 460 if (current[n] != input[n]) 461 break; 462 } 463 464 if (current[n] == input[n]) { 465 result = FALSE; 466 rescan = (n == 0 && d_list->length == 0); 467 } else if (strchr(current + n, '/') == 0 468 && strchr(input + n, '/') == 0) { 469 result = show_both_lists(input, d_list, f_list, keep); 470 } else { 471 rescan = TRUE; 472 } 473 474 if (rescan) { 475 DIR *dp; 476 size_t have = strlen(input); 477 char *leaf; 478 479 if (have > MAX_LEN) 480 have = MAX_LEN; 481 memcpy(current, input, have); 482 current[have] = '\0'; 483 484 /* refill the lists */ 485 free_list(d_list, TRUE); 486 free_list(f_list, TRUE); 487 memcpy(path, current, have); 488 path[have] = '\0'; 489 if ((leaf = strrchr(path, '/')) != 0) { 490 *++leaf = 0; 491 } else { 492 strcpy(path, "./"); 493 leaf = path + strlen(path); 494 } 495 DLG_TRACE(("opendir '%s'\n", path)); 496 if ((dp = opendir(path)) != 0) { 497 DIRENT *de; 498 499 while ((de = readdir(dp)) != 0) { 500 size_t len = NAMLEN(de); 501 if (len == 0 || (len + have + 2) >= MAX_LEN) 502 continue; 503 memcpy(leaf, de->d_name, len); 504 leaf[len] = '\0'; 505 if (stat(path, &sb) == 0) { 506 if ((sb.st_mode & S_IFMT) == S_IFDIR) 507 add_to_list(d_list, leaf); 508 else if (f_list->win) 509 add_to_list(f_list, leaf); 510 } 511 } 512 (void) closedir(dp); 513 /* sort the lists */ 514 if (d_list->data != 0 && d_list->length > 1) { 515 qsort(d_list->data, 516 (size_t) d_list->length, 517 sizeof(d_list->data[0]), 518 compar); 519 } 520 if (f_list->data != 0 && f_list->length > 1) { 521 qsort(f_list->data, 522 (size_t) f_list->length, 523 sizeof(f_list->data[0]), 524 compar); 525 } 526 } 527 528 (void) show_both_lists(input, d_list, f_list, FALSE); 529 d_list->offset = d_list->choice; 530 f_list->offset = f_list->choice; 531 result = TRUE; 532 } 533 return result; 534 } 535 536 static bool 537 usable_state(int state, LIST * dirs, LIST * files) 538 { 539 bool result; 540 541 switch (state) { 542 case sDIRS: 543 result = (dirs->win != 0) && (data_of(dirs) != 0); 544 break; 545 case sFILES: 546 result = (files->win != 0) && (data_of(files) != 0); 547 break; 548 default: 549 result = TRUE; 550 break; 551 } 552 return result; 553 } 554 555 #define which_list() ((state == sFILES) \ 556 ? &f_list \ 557 : ((state == sDIRS) \ 558 ? &d_list \ 559 : 0)) 560 #define NAVIGATE_BINDINGS \ 561 DLG_KEYS_DATA( DLGK_FIELD_NEXT, KEY_RIGHT ), \ 562 DLG_KEYS_DATA( DLGK_FIELD_NEXT, TAB ), \ 563 DLG_KEYS_DATA( DLGK_FIELD_PREV, KEY_BTAB ), \ 564 DLG_KEYS_DATA( DLGK_ITEM_NEXT, KEY_DOWN ), \ 565 DLG_KEYS_DATA( DLGK_ITEM_NEXT, CHR_NEXT ), \ 566 DLG_KEYS_DATA( DLGK_ITEM_NEXT, KEY_NEXT ), \ 567 DLG_KEYS_DATA( DLGK_ITEM_PREV, CHR_PREVIOUS ), \ 568 DLG_KEYS_DATA( DLGK_ITEM_PREV, KEY_UP ), \ 569 DLG_KEYS_DATA( DLGK_PAGE_NEXT, KEY_NPAGE ), \ 570 DLG_KEYS_DATA( DLGK_PAGE_PREV, KEY_PPAGE ) 571 572 /* 573 * Display a dialog box for entering a filename 574 */ 575 static int 576 dlg_fselect(const char *title, const char *path, int height, int width, int dselect) 577 { 578 /* *INDENT-OFF* */ 579 static DLG_KEYS_BINDING binding[] = { 580 HELPKEY_BINDINGS, 581 ENTERKEY_BINDINGS, 582 NAVIGATE_BINDINGS, 583 TOGGLEKEY_BINDINGS, 584 END_KEYS_BINDING 585 }; 586 static DLG_KEYS_BINDING binding2[] = { 587 INPUTSTR_BINDINGS, 588 HELPKEY_BINDINGS, 589 ENTERKEY_BINDINGS, 590 NAVIGATE_BINDINGS, 591 TOGGLEKEY_BINDINGS, 592 END_KEYS_BINDING 593 }; 594 /* *INDENT-ON* */ 595 596 #ifdef KEY_RESIZE 597 int old_height = height; 598 int old_width = width; 599 bool resized = FALSE; 600 #endif 601 int tbox_y, tbox_x, tbox_width, tbox_height; 602 int dbox_y, dbox_x, dbox_width, dbox_height; 603 int fbox_y, fbox_x, fbox_width, fbox_height; 604 int show_buttons = TRUE; 605 int offset = 0; 606 int key = 0; 607 int fkey = FALSE; 608 int code; 609 int result = DLG_EXIT_UNKNOWN; 610 int state = dialog_vars.default_button >= 0 ? dlg_default_button() : sTEXT; 611 int button; 612 bool first = (state == sTEXT); 613 bool first_trace = TRUE; 614 char *input; 615 char *completed; 616 char current[MAX_LEN + 1]; 617 WINDOW *dialog = 0; 618 WINDOW *w_text = 0; 619 WINDOW *w_work = 0; 620 const char **buttons = dlg_ok_labels(); 621 const char *d_label = _("Directories"); 622 const char *f_label = _("Files"); 623 char *partial = 0; 624 int min_wide = MIN_WIDE; 625 int min_items = height ? 0 : 4; 626 LIST d_list, f_list; 627 628 DLG_TRACE(("# %s args:\n", dselect ? "dselect" : "fselect")); 629 DLG_TRACE2S("title", title); 630 DLG_TRACE2S("path", path); 631 DLG_TRACE2N("height", height); 632 DLG_TRACE2N("width", width); 633 634 dlg_does_output(); 635 636 /* Set up the initial value */ 637 input = dlg_set_result(path); 638 offset = (int) strlen(input); 639 *current = 0; 640 641 dlg_button_layout(buttons, &min_wide); 642 643 #ifdef KEY_RESIZE 644 retry: 645 #endif 646 dlg_auto_size(title, "", &height, &width, MIN_HIGH + min_items, min_wide); 647 648 dlg_print_size(height, width); 649 dlg_ctl_size(height, width); 650 651 dialog = dlg_new_window(height, width, 652 dlg_box_y_ordinate(height), 653 dlg_box_x_ordinate(width)); 654 dlg_register_window(dialog, "fselect", binding); 655 dlg_register_buttons(dialog, "fselect", buttons); 656 657 dlg_mouse_setbase(0, 0); 658 659 dlg_draw_box2(dialog, 0, 0, height, width, dialog_attr, border_attr, border2_attr); 660 dlg_draw_bottom_box2(dialog, border_attr, border2_attr, dialog_attr); 661 dlg_draw_title(dialog, title); 662 663 dlg_attrset(dialog, dialog_attr); 664 665 /* Draw the input field box */ 666 tbox_height = 1; 667 tbox_width = width - (4 * MARGIN + 2); 668 tbox_y = height - (BTN_HIGH * 2) + MARGIN; 669 tbox_x = (width - tbox_width) / 2; 670 671 w_text = derwin(dialog, tbox_height, tbox_width, tbox_y, tbox_x); 672 if (w_text == 0) { 673 result = DLG_EXIT_ERROR; 674 goto finish; 675 } 676 677 (void) keypad(w_text, TRUE); 678 dlg_draw_box(dialog, tbox_y - MARGIN, tbox_x - MARGIN, 679 (2 * MARGIN + 1), tbox_width + (MARGIN + EXT_WIDE), 680 menubox_border_attr, menubox_border2_attr); 681 dlg_mouse_mkbigregion(getbegy(dialog) + tbox_y - MARGIN, 682 getbegx(dialog) + tbox_x - MARGIN, 683 1 + (2 * MARGIN), 684 tbox_width + (MARGIN + EXT_WIDE), 685 MOUSE_T, 1, 1, 3 /* doesn't matter */ ); 686 687 dlg_register_window(w_text, "fselect2", binding2); 688 689 /* Draw the directory listing box */ 690 if (dselect) 691 dbox_width = (width - (6 * MARGIN)); 692 else 693 dbox_width = (width - (6 * MARGIN + 2 * EXT_WIDE)) / 2; 694 dbox_height = height - MIN_HIGH; 695 dbox_y = (2 * MARGIN + 1); 696 dbox_x = tbox_x; 697 698 w_work = derwin(dialog, dbox_height, dbox_width, dbox_y, dbox_x); 699 if (w_work == 0) { 700 result = DLG_EXIT_ERROR; 701 goto finish; 702 } 703 704 (void) keypad(w_work, TRUE); 705 (void) mvwaddstr(dialog, dbox_y - (MARGIN + 1), dbox_x - MARGIN, d_label); 706 dlg_draw_box(dialog, 707 dbox_y - MARGIN, dbox_x - MARGIN, 708 dbox_height + (MARGIN + 1), dbox_width + (MARGIN + 1), 709 menubox_border_attr, menubox_border2_attr); 710 init_list(&d_list, dialog, w_work, MOUSE_D); 711 712 if (!dselect) { 713 /* Draw the filename listing box */ 714 fbox_height = dbox_height; 715 fbox_width = dbox_width; 716 fbox_y = dbox_y; 717 fbox_x = tbox_x + dbox_width + (2 * MARGIN); 718 719 w_work = derwin(dialog, fbox_height, fbox_width, fbox_y, fbox_x); 720 if (w_work == 0) { 721 result = DLG_EXIT_ERROR; 722 goto finish; 723 } 724 725 (void) keypad(w_work, TRUE); 726 (void) mvwaddstr(dialog, fbox_y - (MARGIN + 1), fbox_x - MARGIN, f_label); 727 dlg_draw_box(dialog, 728 fbox_y - MARGIN, fbox_x - MARGIN, 729 fbox_height + (MARGIN + 1), fbox_width + (MARGIN + 1), 730 menubox_border_attr, menubox_border2_attr); 731 init_list(&f_list, dialog, w_work, MOUSE_F); 732 } else { 733 memset(&f_list, 0, sizeof(f_list)); 734 } 735 736 while (result == DLG_EXIT_UNKNOWN) { 737 738 if (fill_lists(current, input, &d_list, &f_list, state < sTEXT)) 739 show_buttons = TRUE; 740 741 #ifdef KEY_RESIZE 742 if (resized) { 743 resized = FALSE; 744 dlg_show_string(w_text, input, offset, inputbox_attr, 745 0, 0, tbox_width, FALSE, first); 746 } 747 #endif 748 749 /* 750 * The last field drawn determines where the cursor is shown: 751 */ 752 if (show_buttons) { 753 show_buttons = FALSE; 754 button = (state < 0) ? 0 : state; 755 dlg_draw_buttons(dialog, height - 2, 0, buttons, button, FALSE, width); 756 } 757 758 if (first_trace) { 759 first_trace = FALSE; 760 dlg_trace_win(dialog); 761 } 762 763 if (state < 0) { 764 switch (state) { 765 case sTEXT: 766 dlg_set_focus(dialog, w_text); 767 break; 768 case sFILES: 769 dlg_set_focus(dialog, f_list.win); 770 break; 771 case sDIRS: 772 dlg_set_focus(dialog, d_list.win); 773 break; 774 } 775 } 776 777 if (first) { 778 (void) wrefresh(dialog); 779 } else { 780 fix_arrows(&d_list); 781 fix_arrows(&f_list); 782 key = dlg_mouse_wgetch((state == sTEXT) ? w_text : dialog, &fkey); 783 if (dlg_result_key(key, fkey, &result)) { 784 if (!dlg_button_key(result, &button, &key, &fkey)) 785 break; 786 } 787 } 788 789 if (key == DLGK_TOGGLE) { 790 key = DLGK_SELECT; 791 fkey = TRUE; 792 } 793 794 if (fkey) { 795 switch (key) { 796 case DLGK_MOUSE(KEY_PREVIOUS): 797 state = sDIRS; 798 scroll_list(-1, which_list()); 799 continue; 800 case DLGK_MOUSE(KEY_NEXT): 801 state = sDIRS; 802 scroll_list(1, which_list()); 803 continue; 804 case DLGK_MOUSE(KEY_PPAGE): 805 state = sFILES; 806 scroll_list(-1, which_list()); 807 continue; 808 case DLGK_MOUSE(KEY_NPAGE): 809 state = sFILES; 810 scroll_list(1, which_list()); 811 continue; 812 case DLGK_PAGE_PREV: 813 scroll_list(-1, which_list()); 814 continue; 815 case DLGK_PAGE_NEXT: 816 scroll_list(1, which_list()); 817 continue; 818 case DLGK_ITEM_PREV: 819 if (change_list(-1, which_list())) 820 continue; 821 /* FALLTHRU */ 822 case DLGK_FIELD_PREV: 823 show_buttons = TRUE; 824 do { 825 state = dlg_prev_ok_buttonindex(state, sDIRS); 826 } while (!usable_state(state, &d_list, &f_list)); 827 continue; 828 case DLGK_ITEM_NEXT: 829 if (change_list(1, which_list())) 830 continue; 831 /* FALLTHRU */ 832 case DLGK_FIELD_NEXT: 833 show_buttons = TRUE; 834 do { 835 state = dlg_next_ok_buttonindex(state, sDIRS); 836 } while (!usable_state(state, &d_list, &f_list)); 837 continue; 838 case DLGK_SELECT: 839 completed = 0; 840 if (partial != 0) { 841 free(partial); 842 partial = 0; 843 } 844 if (state == sFILES && !dselect) { 845 completed = data_of(&f_list); 846 } else if (state == sDIRS) { 847 completed = data_of(&d_list); 848 } else { 849 if (complete(input, &d_list, &f_list, &partial)) { 850 completed = partial; 851 } 852 } 853 if (completed != 0) { 854 state = sTEXT; 855 show_buttons = TRUE; 856 strcpy(leaf_of(input), completed); 857 offset = (int) strlen(input); 858 dlg_show_string(w_text, input, offset, inputbox_attr, 859 0, 0, tbox_width, 0, first); 860 if (partial != NULL) { 861 free(partial); 862 partial = 0; 863 } 864 continue; 865 } else { /* if (state < sTEXT) */ 866 (void) beep(); 867 continue; 868 } 869 /* FALLTHRU */ 870 case DLGK_ENTER: 871 result = (state > 0) ? dlg_enter_buttoncode(state) : DLG_EXIT_OK; 872 continue; 873 #ifdef KEY_RESIZE 874 case KEY_RESIZE: 875 dlg_will_resize(dialog); 876 /* reset data */ 877 height = old_height; 878 width = old_width; 879 show_buttons = TRUE; 880 *current = 0; 881 resized = TRUE; 882 /* repaint */ 883 free_list(&d_list, FALSE); 884 free_list(&f_list, FALSE); 885 _dlg_resize_cleanup(dialog); 886 goto retry; 887 #endif 888 default: 889 if (key >= DLGK_MOUSE(MOUSE_T)) { 890 state = sTEXT; 891 continue; 892 } else if (key >= DLGK_MOUSE(MOUSE_F)) { 893 if (f_list.win != 0) { 894 state = sFILES; 895 f_list.choice = (key - DLGK_MOUSE(MOUSE_F)) + f_list.offset; 896 display_list(&f_list); 897 } 898 continue; 899 } else if (key >= DLGK_MOUSE(MOUSE_D)) { 900 if (d_list.win != 0) { 901 state = sDIRS; 902 d_list.choice = (key - DLGK_MOUSE(MOUSE_D)) + d_list.offset; 903 display_list(&d_list); 904 } 905 continue; 906 } else if (is_DLGK_MOUSE(key) 907 && (code = dlg_ok_buttoncode(key - M_EVENT)) >= 0) { 908 result = code; 909 continue; 910 } 911 break; 912 } 913 } 914 915 if (state < 0) { /* Input box selected if we're editing */ 916 int edit = dlg_edit_string(input, &offset, key, fkey, first); 917 918 if (edit) { 919 dlg_show_string(w_text, input, offset, inputbox_attr, 920 0, 0, tbox_width, 0, first); 921 first = FALSE; 922 state = sTEXT; 923 } 924 } else if (state >= 0 && 925 (code = dlg_char_to_button(key, buttons)) >= 0) { 926 result = dlg_ok_buttoncode(code); 927 break; 928 } 929 } 930 AddLastKey(); 931 932 dlg_unregister_window(w_text); 933 dlg_del_window(dialog); 934 dlg_mouse_free_regions(); 935 free_list(&d_list, FALSE); 936 free_list(&f_list, FALSE); 937 938 finish: 939 if (partial != 0) 940 free(partial); 941 return result; 942 } 943 944 /* 945 * Display a dialog box for entering a filename 946 */ 947 int 948 dialog_fselect(const char *title, const char *path, int height, int width) 949 { 950 return dlg_fselect(title, path, height, width, FALSE); 951 } 952 953 /* 954 * Display a dialog box for entering a directory 955 */ 956 int 957 dialog_dselect(const char *title, const char *path, int height, int width) 958 { 959 return dlg_fselect(title, path, height, width, TRUE); 960 } 961