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 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 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 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 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 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 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 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 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 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 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 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 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 376 free_match(MATCH * match_list) 377 { 378 free(match_list->data); 379 match_list->length = 0; 380 } 381 382 static int 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 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 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 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 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 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