1 /* 2 * $Id: textbox.c,v 1.128 2022/04/03 22:38:16 tom Exp $ 3 * 4 * textbox.c -- implements the text box 5 * 6 * Copyright 2000-2021,2022 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 * An earlier version of this program lists as authors: 24 * Savio Lam (lam836@cs.cuhk.hk) 25 */ 26 27 #include <dlg_internals.h> 28 #include <dlg_keys.h> 29 30 #define PAGE_LENGTH (height - 4) 31 #define PAGE_WIDTH (width - 2) 32 33 typedef struct { 34 DIALOG_CALLBACK obj; 35 WINDOW *text; 36 const char **buttons; 37 int hscroll; 38 char line[MAX_LEN + 1]; 39 int fd; 40 long file_size; 41 long fd_bytes_read; 42 long bytes_read; 43 long buffer_len; 44 bool begin_reached; 45 bool buffer_first; 46 bool end_reached; 47 long page_length; /* lines on the page which is shown */ 48 long in_buf; /* ending index into buf[] for page */ 49 char *buf; 50 } MY_OBJ; 51 52 static long 53 lseek_obj(MY_OBJ * obj, long offset, int mode) 54 { 55 long fpos; 56 if ((fpos = (long) lseek(obj->fd, (off_t) offset, mode)) == -1) { 57 switch (mode) { 58 default: 59 case SEEK_CUR: 60 dlg_exiterr("Cannot get file position"); 61 break; 62 case SEEK_END: 63 dlg_exiterr("Cannot seek to end of file"); 64 break; 65 case SEEK_SET: 66 dlg_exiterr("Cannot set file position to %ld", offset); 67 break; 68 } 69 } 70 return fpos; 71 } 72 73 static long 74 ftell_obj(MY_OBJ * obj) 75 { 76 return lseek_obj(obj, 0L, SEEK_CUR); 77 } 78 79 static void 80 lseek_set(MY_OBJ * obj, long offset) 81 { 82 long actual = lseek_obj(obj, offset, SEEK_SET); 83 84 if (actual != offset) { 85 dlg_exiterr("Cannot set file position to %ld (actual %ld)\n", 86 offset, actual); 87 } 88 } 89 90 static void 91 lseek_end(MY_OBJ * obj, long offset) 92 { 93 long actual = lseek_obj(obj, offset, SEEK_END); 94 95 if (offset == 0L && actual > offset) { 96 obj->file_size = actual; 97 } 98 } 99 100 static void 101 lseek_cur(MY_OBJ * obj, long offset) 102 { 103 long actual = lseek_obj(obj, offset, SEEK_CUR); 104 105 if (actual != offset) { 106 DLG_TRACE(("# Lseek returned %ld, expected %ld\n", actual, offset)); 107 } 108 } 109 110 static char * 111 xalloc(size_t size) 112 { 113 char *result = dlg_malloc(char, size); 114 assert_ptr(result, "xalloc"); 115 return result; 116 } 117 118 /* 119 * read_high() substitutes read() for tab->spaces conversion 120 * 121 * buffer_len, fd_bytes_read, bytes_read are modified 122 * buf is allocated 123 * 124 * fd_bytes_read is the effective number of bytes read from file 125 * bytes_read is the length of buf, that can be different if tab_correct 126 */ 127 static void 128 read_high(MY_OBJ * obj, size_t size_read) 129 { 130 char *buftab; 131 132 /* Allocate space for read buffer */ 133 buftab = xalloc(size_read + 1); 134 135 if ((obj->fd_bytes_read = read(obj->fd, buftab, size_read)) != -1) { 136 int j; 137 long begin_line; 138 139 buftab[obj->fd_bytes_read] = '\0'; /* mark end of valid data */ 140 141 if (dialog_vars.tab_correct) { 142 143 /* calculate bytes_read by buftab and fd_bytes_read */ 144 obj->bytes_read = begin_line = 0; 145 for (j = 0; j < obj->fd_bytes_read; j++) 146 if (buftab[j] == TAB) 147 obj->bytes_read += dialog_state.tab_len 148 - ((obj->bytes_read - begin_line) 149 % dialog_state.tab_len); 150 else if (buftab[j] == '\n') { 151 obj->bytes_read++; 152 begin_line = obj->bytes_read; 153 } else 154 obj->bytes_read++; 155 156 if (obj->bytes_read > obj->buffer_len) { 157 if (obj->buffer_first) 158 obj->buffer_first = FALSE; /* disp = 0 */ 159 else { 160 free(obj->buf); 161 } 162 163 obj->buffer_len = obj->bytes_read; 164 165 /* Allocate space for read buffer */ 166 obj->buf = xalloc((size_t) obj->buffer_len + 1); 167 } 168 169 } else { 170 if (obj->buffer_first) { 171 obj->buffer_first = FALSE; 172 173 /* Allocate space for read buffer */ 174 obj->buf = xalloc(size_read + 1); 175 } 176 177 obj->bytes_read = obj->fd_bytes_read; 178 } 179 180 j = 0; 181 begin_line = 0; 182 if (obj->buf != NULL) { 183 int i = 0; 184 185 while (j < obj->fd_bytes_read) { 186 char ch; 187 188 if (((ch = buftab[j++]) == TAB) 189 && (dialog_vars.tab_correct != 0)) { 190 int n; 191 int tmpint = (dialog_state.tab_len 192 - ((int) ((long) i - begin_line) % dialog_state.tab_len)); 193 for (n = 0; n < tmpint; n++) 194 obj->buf[i++] = ' '; 195 } else { 196 if (ch == '\n') 197 begin_line = i + 1; 198 obj->buf[i++] = ch; 199 } 200 } 201 202 obj->buf[i] = '\0'; /* mark end of valid data */ 203 } 204 205 } 206 if (obj->bytes_read == -1) 207 dlg_exiterr("Error reading file"); 208 free(buftab); 209 } 210 211 static long 212 find_first(MY_OBJ * obj, char *buffer, long length) 213 { 214 long result = 0; 215 216 if (buffer != NULL) { 217 long recount = obj->page_length; 218 while (length > 0) { 219 if (buffer[length] == '\n') { 220 if (--recount < 0) { 221 result = length; 222 break; 223 } 224 } 225 --length; 226 } 227 } 228 return result; 229 } 230 231 static long 232 tabize(MY_OBJ * obj, long val, long *first_pos) 233 { 234 long fpos; 235 long i, count, begin_line; 236 char *buftab; 237 238 if (!dialog_vars.tab_correct) 239 return val; 240 241 fpos = ftell_obj(obj); 242 243 lseek_set(obj, fpos - obj->fd_bytes_read); 244 245 /* Allocate space for read buffer */ 246 buftab = xalloc((size_t) val + 1); 247 248 if ((read(obj->fd, buftab, (size_t) val)) == -1) 249 dlg_exiterr("Error reading file in tabize()."); 250 251 begin_line = count = 0; 252 if (first_pos != 0) 253 *first_pos = 0; 254 255 for (i = 0; i < val; i++) { 256 if ((first_pos != 0) && (count >= val)) { 257 *first_pos = find_first(obj, buftab, i); 258 break; 259 } 260 if (buftab[i] == TAB) 261 count += dialog_state.tab_len 262 - ((count - begin_line) % dialog_state.tab_len); 263 else if (buftab[i] == '\n') { 264 count++; 265 begin_line = count; 266 } else 267 count++; 268 } 269 270 lseek_set(obj, fpos); 271 free(buftab); 272 return count; 273 } 274 /* 275 * Return current line of text. 276 * 'page' should point to start of current line before calling, and will be 277 * updated to point to start of next line. 278 */ 279 static char * 280 get_line(MY_OBJ * obj) 281 { 282 int i = 0; 283 284 obj->end_reached = FALSE; 285 if (obj->buf != NULL) { 286 while (obj->buf[obj->in_buf] != '\n') { 287 if (obj->buf[obj->in_buf] == '\0') { /* Either end of file or end of buffer reached */ 288 long fpos = ftell_obj(obj); 289 290 if (fpos < obj->file_size) { /* Not end of file yet */ 291 /* We've reached end of buffer, but not end of file yet, so 292 * read next part of file into buffer 293 */ 294 read_high(obj, BUF_SIZE); 295 obj->in_buf = 0; 296 } else { 297 if (!obj->end_reached) 298 obj->end_reached = TRUE; 299 break; 300 } 301 } else if (i < MAX_LEN) 302 obj->line[i++] = obj->buf[obj->in_buf++]; 303 else { 304 if (i == MAX_LEN) /* Truncate lines longer than MAX_LEN characters */ 305 obj->line[i++] = '\0'; 306 obj->in_buf++; 307 } 308 } 309 } 310 if (i <= MAX_LEN) 311 obj->line[i] = '\0'; 312 if (!obj->end_reached) 313 obj->in_buf++; /* move past '\n' */ 314 315 return obj->line; 316 } 317 318 static bool 319 match_string(MY_OBJ * obj, char *string) 320 { 321 char *match = get_line(obj); 322 return strstr(match, string) != 0; 323 } 324 325 /* 326 * Go back 'n' lines in text file. Called by dialog_textbox(). 327 * 'in_buf' will be updated to point to the desired line in 'buf'. 328 */ 329 static void 330 back_lines(MY_OBJ * obj, long n) 331 { 332 int i; 333 long fpos; 334 long val_to_tabize; 335 336 obj->begin_reached = FALSE; 337 /* We have to distinguish between end_reached and !end_reached since at end 338 * of file, the line is not ended by a '\n'. The code inside 'if' 339 * basically does a '--in_buf' to move one character backward so as to 340 * skip '\n' of the previous line */ 341 if (!obj->end_reached) { 342 /* Either beginning of buffer or beginning of file reached? */ 343 344 if (obj->in_buf == 0) { 345 fpos = ftell_obj(obj); 346 347 if (fpos > obj->fd_bytes_read) { /* Not beginning of file yet */ 348 /* We've reached beginning of buffer, but not beginning of file 349 * yet, so read previous part of file into buffer. Note that 350 * we only move backward for BUF_SIZE/2 bytes, but not BUF_SIZE 351 * bytes to avoid re-reading again in print_page() later 352 */ 353 /* Really possible to move backward BUF_SIZE/2 bytes? */ 354 if (fpos < BUF_SIZE / 2 + obj->fd_bytes_read) { 355 /* No, move less than */ 356 lseek_set(obj, 0L); 357 val_to_tabize = fpos - obj->fd_bytes_read; 358 } else { /* Move backward BUF_SIZE/2 bytes */ 359 lseek_cur(obj, -(BUF_SIZE / 2 + obj->fd_bytes_read)); 360 val_to_tabize = BUF_SIZE / 2; 361 } 362 read_high(obj, BUF_SIZE); 363 364 obj->in_buf = tabize(obj, val_to_tabize, (long *) 0); 365 366 } else { /* Beginning of file reached */ 367 obj->begin_reached = TRUE; 368 return; 369 } 370 } 371 obj->in_buf--; 372 if (obj->buf == NULL 373 || obj->in_buf < 0 374 || obj->in_buf >= obj->bytes_read 375 || obj->buf[obj->in_buf] != '\n') 376 /* Something's wrong... */ 377 dlg_exiterr("Internal error in back_lines()."); 378 } 379 380 /* Go back 'n' lines */ 381 for (i = 0; i < n; i++) { 382 do { 383 if (obj->in_buf == 0) { 384 fpos = ftell_obj(obj); 385 386 if (fpos > obj->fd_bytes_read) { 387 /* Really possible to move backward BUF_SIZE/2 bytes? */ 388 if (fpos < BUF_SIZE / 2 + obj->fd_bytes_read) { 389 /* No, move less than */ 390 lseek_set(obj, 0L); 391 val_to_tabize = fpos - obj->fd_bytes_read; 392 } else { /* Move backward BUF_SIZE/2 bytes */ 393 lseek_cur(obj, -(BUF_SIZE / 2 + obj->fd_bytes_read)); 394 val_to_tabize = BUF_SIZE / 2; 395 } 396 read_high(obj, BUF_SIZE); 397 398 obj->in_buf = tabize(obj, val_to_tabize, (long *) 0); 399 400 } else { /* Beginning of file reached */ 401 obj->begin_reached = TRUE; 402 return; 403 } 404 } 405 } while (obj->buf[--(obj->in_buf)] != '\n'); 406 } 407 obj->in_buf++; 408 } 409 410 /* 411 * Print a new line of text. 412 */ 413 static void 414 print_line(MY_OBJ * obj, int row, int width) 415 { 416 if (wmove(obj->text, row, 0) != ERR) { 417 int i, y, x; 418 char *line = get_line(obj); 419 const int *cols = dlg_index_columns(line); 420 const int *indx = dlg_index_wchars(line); 421 int limit = dlg_count_wchars(line); 422 int first = 0; 423 int last = limit; 424 425 if (width > getmaxx(obj->text)) 426 width = getmaxx(obj->text); 427 --width; /* for the leading ' ' */ 428 429 for (i = 0; i <= limit && cols[i] < obj->hscroll; ++i) 430 first = i; 431 432 for (i = first; (i <= limit) && ((cols[i] - cols[first]) < width); ++i) 433 last = i; 434 435 (void) waddch(obj->text, ' '); 436 (void) waddnstr(obj->text, line + indx[first], indx[last] - indx[first]); 437 438 getyx(obj->text, y, x); 439 if (y == row) { /* Clear 'residue' of previous line */ 440 for (i = 0; i <= width - x; i++) { 441 (void) waddch(obj->text, ' '); 442 } 443 } 444 } 445 } 446 447 /* 448 * Print a new page of text. 449 */ 450 static void 451 print_page(MY_OBJ * obj, int height, int width) 452 { 453 int i, passed_end = 0; 454 455 obj->page_length = 0; 456 for (i = 0; i < height; i++) { 457 print_line(obj, i, width); 458 if (!passed_end) 459 obj->page_length++; 460 if (obj->end_reached && !passed_end) 461 passed_end = 1; 462 } 463 (void) wnoutrefresh(obj->text); 464 dlg_trace_win(obj->text); 465 } 466 467 /* 468 * Print current position 469 */ 470 static void 471 print_position(MY_OBJ * obj, WINDOW *win, int height, int width) 472 { 473 long fpos; 474 long size; 475 long first = -1; 476 477 fpos = ftell_obj(obj); 478 if (dialog_vars.tab_correct) 479 size = tabize(obj, obj->in_buf, &first); 480 else 481 first = find_first(obj, obj->buf, size = obj->in_buf); 482 483 dlg_draw_scrollbar(win, 484 first, 485 fpos - obj->fd_bytes_read + size, 486 fpos - obj->fd_bytes_read + size, 487 obj->file_size, 488 0, PAGE_WIDTH, 489 0, PAGE_LENGTH + 1, 490 border_attr, 491 border_attr); 492 } 493 494 /* 495 * Display a dialog box and get the search term from user. 496 */ 497 static int 498 get_search_term(WINDOW *dialog, char *input, int height, int width) 499 { 500 /* *INDENT-OFF* */ 501 static DLG_KEYS_BINDING binding[] = { 502 INPUTSTR_BINDINGS, 503 HELPKEY_BINDINGS, 504 ENTERKEY_BINDINGS, 505 END_KEYS_BINDING 506 }; 507 /* *INDENT-ON* */ 508 509 int old_x, old_y; 510 int box_x, box_y; 511 int box_height, box_width; 512 int offset = 0; 513 int key = 0; 514 int fkey = 0; 515 bool first = TRUE; 516 int result = DLG_EXIT_UNKNOWN; 517 const char *caption = _("Search"); 518 int len_caption = dlg_count_columns(caption); 519 const int *indx; 520 int limit; 521 WINDOW *widget; 522 523 getbegyx(dialog, old_y, old_x); 524 525 box_height = 1 + (2 * MARGIN); 526 box_width = len_caption + (2 * (MARGIN + 2)); 527 box_width = MAX(box_width, 30); 528 box_width = MIN(box_width, getmaxx(dialog) - 2 * MARGIN); 529 len_caption = MIN(len_caption, box_width - (2 * (MARGIN + 1))); 530 531 box_x = (width - box_width) / 2; 532 box_y = (height - box_height) / 2; 533 widget = dlg_new_modal_window(dialog, 534 box_height, box_width, 535 old_y + box_y, old_x + box_x); 536 keypad(widget, TRUE); 537 dlg_register_window(widget, "searchbox", binding); 538 539 dlg_draw_box2(widget, 0, 0, box_height, box_width, 540 searchbox_attr, 541 searchbox_border_attr, 542 searchbox_border2_attr); 543 dlg_attrset(widget, searchbox_title_attr); 544 (void) wmove(widget, 0, (box_width - len_caption) / 2); 545 546 indx = dlg_index_wchars(caption); 547 limit = dlg_limit_columns(caption, len_caption, 0); 548 (void) waddnstr(widget, caption + indx[0], indx[limit] - indx[0]); 549 550 box_width -= 2; 551 offset = dlg_count_columns(input); 552 553 while (result == DLG_EXIT_UNKNOWN) { 554 if (!first) { 555 key = dlg_getc(widget, &fkey); 556 if (fkey) { 557 switch (fkey) { 558 #ifdef KEY_RESIZE 559 case KEY_RESIZE: 560 result = DLG_EXIT_CANCEL; 561 continue; 562 #endif 563 case DLGK_ENTER: 564 result = DLG_EXIT_OK; 565 continue; 566 } 567 } else if (key == ESC) { 568 result = DLG_EXIT_ESC; 569 continue; 570 } else if (key == ERR) { 571 napms(50); 572 continue; 573 } 574 } 575 if (dlg_edit_string(input, &offset, key, fkey, first)) { 576 dlg_show_string(widget, input, offset, searchbox_attr, 577 1, 1, box_width, FALSE, first); 578 first = FALSE; 579 } 580 } 581 dlg_del_window(widget); 582 return result; 583 } 584 585 static bool 586 perform_search(MY_OBJ * obj, int height, int width, int key, char *search_term) 587 { 588 int dir; 589 bool moved = FALSE; 590 591 /* set search direction */ 592 dir = (key == '/' || key == 'n') ? 1 : 0; 593 if (dir ? !obj->end_reached : !obj->begin_reached) { 594 long tempinx; 595 long fpos; 596 int result; 597 bool found; 598 bool temp, temp1; 599 600 if (key == 'n' || key == 'N') { 601 if (search_term[0] == '\0') { /* No search term yet */ 602 (void) beep(); 603 return FALSE; 604 } 605 /* Get search term from user */ 606 } else if ((result = get_search_term(obj->text, search_term, 607 PAGE_LENGTH, 608 PAGE_WIDTH)) != DLG_EXIT_OK 609 || search_term[0] == '\0') { 610 #ifdef KEY_RESIZE 611 if (result == DLG_EXIT_CANCEL) { 612 ungetch(key); 613 ungetch(KEY_RESIZE); 614 /* FALLTHRU */ 615 } 616 #else 617 (void) result; 618 #endif 619 /* ESC pressed, or no search term, reprint page to clear box */ 620 dlg_attrset(obj->text, dialog_attr); 621 back_lines(obj, obj->page_length); 622 return TRUE; 623 } 624 /* Save variables for restoring in case search term can't be found */ 625 tempinx = obj->in_buf; 626 temp = obj->begin_reached; 627 temp1 = obj->end_reached; 628 fpos = ftell_obj(obj) - obj->fd_bytes_read; 629 /* update 'in_buf' to point to next (previous) line before 630 forward (backward) searching */ 631 back_lines(obj, (dir 632 ? obj->page_length - 1 633 : obj->page_length + 1)); 634 if (dir) { /* Forward search */ 635 while ((found = match_string(obj, search_term)) == FALSE) { 636 if (obj->end_reached) 637 break; 638 } 639 } else { /* Backward search */ 640 while ((found = match_string(obj, search_term)) == FALSE) { 641 if (obj->begin_reached) 642 break; 643 back_lines(obj, 2L); 644 } 645 } 646 if (found == FALSE) { /* not found */ 647 (void) beep(); 648 /* Restore program state to that before searching */ 649 lseek_set(obj, fpos); 650 651 read_high(obj, BUF_SIZE); 652 653 obj->in_buf = tempinx; 654 obj->begin_reached = temp; 655 obj->end_reached = temp1; 656 /* move 'in_buf' to point to start of current page to 657 * re-print current page. Note that 'in_buf' always points 658 * to start of next page, so this is necessary 659 */ 660 back_lines(obj, obj->page_length); 661 } else { /* Search term found */ 662 back_lines(obj, 1L); 663 } 664 /* Reprint page */ 665 dlg_attrset(obj->text, dialog_attr); 666 moved = TRUE; 667 } else { /* no need to find */ 668 (void) beep(); 669 } 670 return moved; 671 } 672 673 /* 674 * Display text from a file in a dialog box. 675 */ 676 int 677 dialog_textbox(const char *title, const char *filename, int height, int width) 678 { 679 /* *INDENT-OFF* */ 680 static DLG_KEYS_BINDING binding[] = { 681 HELPKEY_BINDINGS, 682 ENTERKEY_BINDINGS, 683 DLG_KEYS_DATA( DLGK_GRID_DOWN, 'J' ), 684 DLG_KEYS_DATA( DLGK_GRID_DOWN, 'j' ), 685 DLG_KEYS_DATA( DLGK_GRID_DOWN, KEY_DOWN ), 686 DLG_KEYS_DATA( DLGK_GRID_LEFT, 'H' ), 687 DLG_KEYS_DATA( DLGK_GRID_LEFT, 'h' ), 688 DLG_KEYS_DATA( DLGK_GRID_LEFT, KEY_LEFT ), 689 DLG_KEYS_DATA( DLGK_GRID_RIGHT, 'L' ), 690 DLG_KEYS_DATA( DLGK_GRID_RIGHT, 'l' ), 691 DLG_KEYS_DATA( DLGK_GRID_RIGHT, KEY_RIGHT ), 692 DLG_KEYS_DATA( DLGK_GRID_UP, 'K' ), 693 DLG_KEYS_DATA( DLGK_GRID_UP, 'k' ), 694 DLG_KEYS_DATA( DLGK_GRID_UP, KEY_UP ), 695 DLG_KEYS_DATA( DLGK_PAGE_FIRST, 'g' ), 696 DLG_KEYS_DATA( DLGK_PAGE_FIRST, KEY_HOME ), 697 DLG_KEYS_DATA( DLGK_PAGE_LAST, 'G' ), 698 DLG_KEYS_DATA( DLGK_PAGE_LAST, KEY_END ), 699 DLG_KEYS_DATA( DLGK_PAGE_LAST, KEY_LL ), 700 DLG_KEYS_DATA( DLGK_PAGE_NEXT, CHR_SPACE ), 701 DLG_KEYS_DATA( DLGK_PAGE_NEXT, KEY_NPAGE ), 702 DLG_KEYS_DATA( DLGK_PAGE_PREV, 'B' ), 703 DLG_KEYS_DATA( DLGK_PAGE_PREV, 'b' ), 704 DLG_KEYS_DATA( DLGK_PAGE_PREV, KEY_PPAGE ), 705 DLG_KEYS_DATA( DLGK_BEGIN, '0' ), 706 DLG_KEYS_DATA( DLGK_BEGIN, KEY_BEG ), 707 DLG_KEYS_DATA( DLGK_FIELD_NEXT, TAB ), 708 DLG_KEYS_DATA( DLGK_FIELD_PREV, KEY_BTAB ), 709 END_KEYS_BINDING 710 }; 711 /* *INDENT-ON* */ 712 713 #ifdef KEY_RESIZE 714 int old_height = height; 715 int old_width = width; 716 #endif 717 long fpos; 718 int x, y, cur_x, cur_y; 719 int key, fkey; 720 int next = 0; 721 int i, passed_end; 722 char search_term[MAX_LEN + 1]; 723 MY_OBJ obj; 724 WINDOW *dialog; 725 bool moved; 726 int result = DLG_EXIT_UNKNOWN; 727 int button = dlg_default_button(); 728 int min_width = 12; 729 730 DLG_TRACE(("# textbox args:\n")); 731 DLG_TRACE2S("title", title); 732 DLG_TRACE2S("filename", filename); 733 DLG_TRACE2N("height", height); 734 DLG_TRACE2N("width", width); 735 736 search_term[0] = '\0'; /* no search term entered yet */ 737 738 memset(&obj, 0, sizeof(obj)); 739 740 obj.begin_reached = TRUE; 741 obj.buffer_first = TRUE; 742 obj.end_reached = FALSE; 743 obj.buttons = dlg_exit_label(); 744 745 /* Open input file for reading */ 746 if ((obj.fd = open(filename, O_RDONLY)) == -1) 747 dlg_exiterr("Can't open input file %s", filename); 748 749 /* Get file size. Actually, 'file_size' is the real file size - 1, 750 since it's only the last byte offset from the beginning */ 751 lseek_end(&obj, 0L); 752 753 /* Restore file pointer to beginning of file after getting file size */ 754 lseek_set(&obj, 0L); 755 756 read_high(&obj, BUF_SIZE); 757 758 dlg_button_layout(obj.buttons, &min_width); 759 760 #ifdef KEY_RESIZE 761 retry: 762 #endif 763 moved = TRUE; 764 765 dlg_auto_sizefile(title, filename, &height, &width, 2, min_width); 766 dlg_print_size(height, width); 767 dlg_ctl_size(height, width); 768 769 x = dlg_box_x_ordinate(width); 770 y = dlg_box_y_ordinate(height); 771 772 dialog = dlg_new_window(height, width, y, x); 773 dlg_register_window(dialog, "textbox", binding); 774 dlg_register_buttons(dialog, "textbox", obj.buttons); 775 776 dlg_mouse_setbase(x, y); 777 778 /* Create window for text region, used for scrolling text */ 779 obj.text = dlg_sub_window(dialog, PAGE_LENGTH, PAGE_WIDTH, y + 1, x + 1); 780 781 /* register the new window, along with its borders */ 782 dlg_mouse_mkbigregion(0, 0, PAGE_LENGTH + 2, width, KEY_MAX, 1, 1, 1 /* lines */ ); 783 dlg_draw_box2(dialog, 0, 0, height, width, dialog_attr, border_attr, border2_attr); 784 dlg_draw_bottom_box2(dialog, border_attr, border2_attr, dialog_attr); 785 dlg_draw_title(dialog, title); 786 787 dlg_draw_buttons(dialog, PAGE_LENGTH + 2, 0, obj.buttons, button, FALSE, width); 788 (void) wnoutrefresh(dialog); 789 getyx(dialog, cur_y, cur_x); /* Save cursor position */ 790 791 dlg_attr_clear(obj.text, PAGE_LENGTH, PAGE_WIDTH, dialog_attr); 792 793 while (result == DLG_EXIT_UNKNOWN) { 794 int code; 795 796 /* 797 * Update the screen according to whether we shifted up/down by a line 798 * or not. 799 */ 800 if (moved) { 801 if (next < 0) { 802 (void) scrollok(obj.text, TRUE); 803 (void) scroll(obj.text); /* Scroll text region up one line */ 804 (void) scrollok(obj.text, FALSE); 805 print_line(&obj, PAGE_LENGTH - 1, PAGE_WIDTH); 806 (void) wnoutrefresh(obj.text); 807 } else if (next > 0) { 808 /* 809 * We don't call print_page() here but use scrolling to ensure 810 * faster screen update. However, 'end_reached' and 811 * 'page_length' should still be updated, and 'in_buf' should 812 * point to start of next page. This is done by calling 813 * get_line() in the following 'for' loop. 814 */ 815 (void) scrollok(obj.text, TRUE); 816 (void) wscrl(obj.text, -1); /* Scroll text region down one line */ 817 (void) scrollok(obj.text, FALSE); 818 obj.page_length = 0; 819 passed_end = 0; 820 for (i = 0; i < PAGE_LENGTH; i++) { 821 if (!i) { 822 print_line(&obj, 0, PAGE_WIDTH); /* print first line of page */ 823 (void) wnoutrefresh(obj.text); 824 } else 825 (void) get_line(&obj); /* Called to update 'end_reached' and 'in_buf' */ 826 if (!passed_end) 827 obj.page_length++; 828 if (obj.end_reached && !passed_end) 829 passed_end = 1; 830 } 831 } else { 832 print_page(&obj, PAGE_LENGTH, PAGE_WIDTH); 833 } 834 print_position(&obj, dialog, height, width); 835 (void) wmove(dialog, cur_y, cur_x); /* Restore cursor position */ 836 wrefresh(dialog); 837 } 838 moved = FALSE; /* assume we'll not move */ 839 next = 0; /* ...but not scroll by a line */ 840 841 key = dlg_mouse_wgetch(dialog, &fkey); 842 if (dlg_result_key(key, fkey, &result)) { 843 if (!dlg_ok_button_key(result, &button, &key, &fkey)) 844 break; 845 } 846 847 if (!fkey && (code = dlg_char_to_button(key, obj.buttons)) >= 0) { 848 result = dlg_ok_buttoncode(code); 849 break; 850 } 851 852 if (fkey) { 853 switch (key) { 854 default: 855 if (is_DLGK_MOUSE(key)) { 856 result = dlg_exit_buttoncode(key - M_EVENT); 857 if (result < 0) 858 result = DLG_EXIT_OK; 859 } else { 860 beep(); 861 } 862 break; 863 case DLGK_FIELD_NEXT: 864 button = dlg_next_button(obj.buttons, button); 865 if (button < 0) 866 button = 0; 867 dlg_draw_buttons(dialog, 868 height - 2, 0, 869 obj.buttons, button, 870 FALSE, width); 871 break; 872 case DLGK_FIELD_PREV: 873 button = dlg_prev_button(obj.buttons, button); 874 if (button < 0) 875 button = 0; 876 dlg_draw_buttons(dialog, 877 height - 2, 0, 878 obj.buttons, button, 879 FALSE, width); 880 break; 881 case DLGK_ENTER: 882 result = dlg_enter_buttoncode(button); 883 break; 884 case DLGK_LEAVE: 885 result = dlg_ok_buttoncode(button); 886 break; 887 case DLGK_PAGE_FIRST: 888 if (!obj.begin_reached) { 889 obj.begin_reached = 1; 890 /* First page not in buffer? */ 891 fpos = ftell_obj(&obj); 892 893 if (fpos > obj.fd_bytes_read) { 894 /* Yes, we have to read it in */ 895 lseek_set(&obj, 0L); 896 897 read_high(&obj, BUF_SIZE); 898 } 899 obj.in_buf = 0; 900 moved = TRUE; 901 } 902 break; 903 case DLGK_PAGE_LAST: 904 obj.end_reached = TRUE; 905 /* Last page not in buffer? */ 906 fpos = ftell_obj(&obj); 907 908 if (fpos < obj.file_size) { 909 /* Yes, we have to read it in */ 910 lseek_end(&obj, -BUF_SIZE); 911 912 read_high(&obj, BUF_SIZE); 913 } 914 obj.in_buf = obj.bytes_read; 915 back_lines(&obj, (long) PAGE_LENGTH); 916 moved = TRUE; 917 break; 918 case DLGK_GRID_UP: /* Previous line */ 919 if (!obj.begin_reached) { 920 back_lines(&obj, obj.page_length + 1); 921 next = 1; 922 moved = TRUE; 923 } 924 break; 925 case DLGK_PAGE_PREV: /* Previous page */ 926 case DLGK_MOUSE(KEY_PPAGE): 927 if (!obj.begin_reached) { 928 back_lines(&obj, obj.page_length + PAGE_LENGTH); 929 moved = TRUE; 930 } 931 break; 932 case DLGK_GRID_DOWN: /* Next line */ 933 if (!obj.end_reached) { 934 obj.begin_reached = 0; 935 next = -1; 936 moved = TRUE; 937 } 938 break; 939 case DLGK_PAGE_NEXT: /* Next page */ 940 case DLGK_MOUSE(KEY_NPAGE): 941 if (!obj.end_reached) { 942 obj.begin_reached = 0; 943 moved = TRUE; 944 } 945 break; 946 case DLGK_BEGIN: /* Beginning of line */ 947 if (obj.hscroll > 0) { 948 obj.hscroll = 0; 949 /* Reprint current page to scroll horizontally */ 950 back_lines(&obj, obj.page_length); 951 moved = TRUE; 952 } 953 break; 954 case DLGK_GRID_LEFT: /* Scroll left */ 955 if (obj.hscroll > 0) { 956 obj.hscroll--; 957 /* Reprint current page to scroll horizontally */ 958 back_lines(&obj, obj.page_length); 959 moved = TRUE; 960 } 961 break; 962 case DLGK_GRID_RIGHT: /* Scroll right */ 963 if (obj.hscroll < MAX_LEN) { 964 obj.hscroll++; 965 /* Reprint current page to scroll horizontally */ 966 back_lines(&obj, obj.page_length); 967 moved = TRUE; 968 } 969 break; 970 #ifdef KEY_RESIZE 971 case KEY_RESIZE: 972 dlg_will_resize(dialog); 973 /* reset data */ 974 height = old_height; 975 width = old_width; 976 back_lines(&obj, obj.page_length); 977 /* repaint */ 978 _dlg_resize_cleanup(dialog); 979 goto retry; 980 #endif 981 } 982 } else { 983 switch (key) { 984 case '/': /* Forward search */ 985 case 'n': /* Repeat forward search */ 986 case '?': /* Backward search */ 987 case 'N': /* Repeat backward search */ 988 moved = perform_search(&obj, height, width, key, search_term); 989 fkey = FALSE; 990 break; 991 default: 992 beep(); 993 break; 994 } 995 } 996 } 997 dlg_add_last_key(-1); 998 999 dlg_del_window(dialog); 1000 free(obj.buf); 1001 (void) close(obj.fd); 1002 dlg_mouse_free_regions(); 1003 return result; 1004 } 1005