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