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