1/*- 2 * Copyright (c) 1993, 1994 3 * The Regents of the University of California. All rights reserved. 4 * Copyright (c) 1993, 1994, 1995, 1996 5 * Keith Bostic. All rights reserved. 6 * 7 * See the LICENSE file for redistribution information. 8 */ 9 10#include "config.h" 11 12#include <sys/types.h> 13#include <sys/queue.h> 14#include <sys/time.h> 15 16#include <bitstring.h> 17#include <ctype.h> 18#include <signal.h> 19#include <stdio.h> 20#include <stdlib.h> 21#include <string.h> 22#ifdef HAVE_TERM_H 23#include <term.h> 24#endif 25#include <termios.h> 26#include <unistd.h> 27 28#include "../common/common.h" 29#include "../vi/vi.h" 30#include "cl.h" 31 32static void cl_rdiv(SCR *); 33 34static int 35addstr4(SCR *sp, void *str, size_t len, int wide) 36{ 37 CL_PRIVATE *clp; 38 WINDOW *win; 39 size_t y, x; 40 int iv; 41 42 clp = CLP(sp); 43 win = CLSP(sp) ? CLSP(sp) : stdscr; 44 45 /* 46 * If ex isn't in control, it's the last line of the screen and 47 * it's a split screen, use inverse video. 48 */ 49 iv = 0; 50 getyx(win, y, x); 51 if (!F_ISSET(sp, SC_SCR_EXWROTE) && 52 y == RLNO(sp, LASTLINE(sp)) && IS_SPLIT(sp)) { 53 iv = 1; 54 (void)wstandout(win); 55 } 56 57#ifdef USE_WIDECHAR 58 if (wide) { 59 if (waddnwstr(win, str, len) == ERR) 60 return (1); 61 } else 62#endif 63 if (waddnstr(win, str, len) == ERR) 64 return (1); 65 66 if (iv) 67 (void)wstandend(win); 68 return (0); 69} 70 71/* 72 * cl_waddstr -- 73 * Add len bytes from the string at the cursor, advancing the cursor. 74 * 75 * PUBLIC: int cl_waddstr(SCR *, const CHAR_T *, size_t); 76 */ 77int 78cl_waddstr(SCR *sp, const CHAR_T *str, size_t len) 79{ 80 return addstr4(sp, (void *)str, len, 1); 81} 82 83/* 84 * cl_addstr -- 85 * Add len bytes from the string at the cursor, advancing the cursor. 86 * 87 * PUBLIC: int cl_addstr(SCR *, const char *, size_t); 88 */ 89int 90cl_addstr(SCR *sp, const char *str, size_t len) 91{ 92 return addstr4(sp, (void *)str, len, 0); 93} 94 95/* 96 * cl_attr -- 97 * Toggle a screen attribute on/off. 98 * 99 * PUBLIC: int cl_attr(SCR *, scr_attr_t, int); 100 */ 101int 102cl_attr(SCR *sp, scr_attr_t attribute, int on) 103{ 104 CL_PRIVATE *clp; 105 WINDOW *win; 106 107 clp = CLP(sp); 108 win = CLSP(sp) ? CLSP(sp) : stdscr; 109 110 switch (attribute) { 111 case SA_ALTERNATE: 112 /* 113 * !!! 114 * There's a major layering violation here. The problem is that the 115 * X11 xterm screen has what's known as an "alternate" screen. Some 116 * xterm termcap/terminfo entries include sequences to switch to/from 117 * that alternate screen as part of the ti/te (smcup/rmcup) strings. 118 * Vi runs in the alternate screen, so that you are returned to the 119 * same screen contents on exit from vi that you had when you entered 120 * vi. Further, when you run :shell, or :!date or similar ex commands, 121 * you also see the original screen contents. This wasn't deliberate 122 * on vi's part, it's just that it historically sent terminal init/end 123 * sequences at those times, and the addition of the alternate screen 124 * sequences to the strings changed the behavior of vi. The problem 125 * caused by this is that we don't want to switch back to the alternate 126 * screen while getting a new command from the user, when the user is 127 * continuing to enter ex commands, e.g.: 128 * 129 * :!date <<< switch to original screen 130 * [Hit return to continue] <<< prompt user to continue 131 * :command <<< get command from user 132 * 133 * Note that the :command input is a true vi input mode, e.g., input 134 * maps and abbreviations are being done. So, we need to be able to 135 * switch back into the vi screen mode, without flashing the screen. 136 * 137 * To make matters worse, the curses initscr() and endwin() calls will 138 * do this automatically -- so, this attribute isn't as controlled by 139 * the higher level screen as closely as one might like. 140 */ 141 if (on) { 142 if (clp->ti_te != TI_SENT) { 143 clp->ti_te = TI_SENT; 144 if (clp->smcup == NULL) 145 (void)cl_getcap(sp, "smcup", &clp->smcup); 146 if (clp->smcup != NULL) 147 (void)tputs(clp->smcup, 1, cl_putchar); 148 } 149 } else 150 if (clp->ti_te != TE_SENT) { 151 clp->ti_te = TE_SENT; 152 if (clp->rmcup == NULL) 153 (void)cl_getcap(sp, "rmcup", &clp->rmcup); 154 if (clp->rmcup != NULL) 155 (void)tputs(clp->rmcup, 1, cl_putchar); 156 (void)fflush(stdout); 157 } 158 (void)fflush(stdout); 159 break; 160 case SA_INVERSE: 161 if (F_ISSET(sp, SC_EX | SC_SCR_EXWROTE)) { 162 if (clp->smso == NULL) 163 return (1); 164 if (on) 165 (void)tputs(clp->smso, 1, cl_putchar); 166 else 167 (void)tputs(clp->rmso, 1, cl_putchar); 168 (void)fflush(stdout); 169 } else { 170 if (on) 171 (void)wstandout(win); 172 else 173 (void)wstandend(win); 174 } 175 break; 176 default: 177 abort(); 178 } 179 return (0); 180} 181 182/* 183 * cl_baud -- 184 * Return the baud rate. 185 * 186 * PUBLIC: int cl_baud(SCR *, u_long *); 187 */ 188int 189cl_baud(SCR *sp, u_long *ratep) 190{ 191 CL_PRIVATE *clp; 192 193 /* 194 * XXX 195 * There's no portable way to get a "baud rate" -- cfgetospeed(3) 196 * returns the value associated with some #define, which we may 197 * never have heard of, or which may be a purely local speed. Vi 198 * only cares if it's SLOW (w300), slow (w1200) or fast (w9600). 199 * Try and detect the slow ones, and default to fast. 200 */ 201 clp = CLP(sp); 202 switch (cfgetospeed(&clp->orig)) { 203 case B50: 204 case B75: 205 case B110: 206 case B134: 207 case B150: 208 case B200: 209 case B300: 210 case B600: 211 *ratep = 600; 212 break; 213 case B1200: 214 *ratep = 1200; 215 break; 216 default: 217 *ratep = 9600; 218 break; 219 } 220 return (0); 221} 222 223/* 224 * cl_bell -- 225 * Ring the bell/flash the screen. 226 * 227 * PUBLIC: int cl_bell(SCR *); 228 */ 229int 230cl_bell(SCR *sp) 231{ 232 if (F_ISSET(sp, SC_EX | SC_SCR_EXWROTE | SC_SCR_EX)) 233 (void)write(STDOUT_FILENO, "\07", 1); /* \a */ 234 else { 235 /* 236 * Vi has an edit option which determines if the terminal 237 * should be beeped or the screen flashed. 238 */ 239 if (O_ISSET(sp, O_FLASH)) 240 (void)flash(); 241 else 242 (void)beep(); 243 } 244 return (0); 245} 246 247/* 248 * cl_clrtoeol -- 249 * Clear from the current cursor to the end of the line. 250 * 251 * PUBLIC: int cl_clrtoeol(SCR *); 252 */ 253int 254cl_clrtoeol(SCR *sp) 255{ 256 WINDOW *win; 257#if 0 258 size_t spcnt, y, x; 259#endif 260 261 win = CLSP(sp) ? CLSP(sp) : stdscr; 262 263#if 0 264 if (IS_VSPLIT(sp)) { 265 /* The cursor must be returned to its original position. */ 266 getyx(win, y, x); 267 for (spcnt = (sp->coff + sp->cols) - x; spcnt > 0; --spcnt) 268 (void)waddch(win, ' '); 269 (void)wmove(win, y, x); 270 return (0); 271 } else 272#endif 273 return (wclrtoeol(win) == ERR); 274} 275 276/* 277 * cl_cursor -- 278 * Return the current cursor position. 279 * 280 * PUBLIC: int cl_cursor(SCR *, size_t *, size_t *); 281 */ 282int 283cl_cursor(SCR *sp, size_t *yp, size_t *xp) 284{ 285 WINDOW *win; 286 win = CLSP(sp) ? CLSP(sp) : stdscr; 287 /* 288 * The curses screen support splits a single underlying curses screen 289 * into multiple screens to support split screen semantics. For this 290 * reason the returned value must be adjusted to be relative to the 291 * current screen, and not absolute. Screens that implement the split 292 * using physically distinct screens won't need this hack. 293 */ 294 getyx(win, *yp, *xp); 295 /* 296 *yp -= sp->roff; 297 *xp -= sp->coff; 298 */ 299 return (0); 300} 301 302/* 303 * cl_deleteln -- 304 * Delete the current line, scrolling all lines below it. 305 * 306 * PUBLIC: int cl_deleteln(SCR *); 307 */ 308int 309cl_deleteln(SCR *sp) 310{ 311 CL_PRIVATE *clp; 312 WINDOW *win; 313 size_t y, x; 314 315 clp = CLP(sp); 316 win = CLSP(sp) ? CLSP(sp) : stdscr; 317 318 /* 319 * This clause is required because the curses screen uses reverse 320 * video to delimit split screens. If the screen does not do this, 321 * this code won't be necessary. 322 * 323 * If the bottom line was in reverse video, rewrite it in normal 324 * video before it's scrolled. 325 */ 326 if (!F_ISSET(sp, SC_SCR_EXWROTE) && IS_SPLIT(sp)) { 327 getyx(win, y, x); 328 mvwchgat(win, RLNO(sp, LASTLINE(sp)), 0, -1, A_NORMAL, 0, NULL); 329 (void)wmove(win, y, x); 330 } 331 332 /* 333 * The bottom line is expected to be blank after this operation, 334 * and other screens must support that semantic. 335 */ 336 return (wdeleteln(win) == ERR); 337} 338 339/* 340 * cl_discard -- 341 * Discard a screen. 342 * 343 * PUBLIC: int cl_discard(SCR *, SCR **); 344 */ 345int 346cl_discard(SCR *discardp, SCR **acquirep) 347{ 348 CL_PRIVATE *clp; 349 SCR* tsp; 350 351 if (discardp) { 352 clp = CLP(discardp); 353 F_SET(clp, CL_LAYOUT); 354 355 if (CLSP(discardp)) { 356 delwin(CLSP(discardp)); 357 discardp->cl_private = NULL; 358 } 359 } 360 361 /* no screens got a piece; we're done */ 362 if (!acquirep) 363 return 0; 364 365 for (; (tsp = *acquirep) != NULL; ++acquirep) { 366 clp = CLP(tsp); 367 F_SET(clp, CL_LAYOUT); 368 369 if (CLSP(tsp)) 370 delwin(CLSP(tsp)); 371 tsp->cl_private = subwin(stdscr, tsp->rows, tsp->cols, 372 tsp->roff, tsp->coff); 373 } 374 375 /* discardp is going away, acquirep is taking up its space. */ 376 return (0); 377} 378 379/* 380 * cl_ex_adjust -- 381 * Adjust the screen for ex. This routine is purely for standalone 382 * ex programs. All special purpose, all special case. 383 * 384 * PUBLIC: int cl_ex_adjust(SCR *, exadj_t); 385 */ 386int 387cl_ex_adjust(SCR *sp, exadj_t action) 388{ 389 CL_PRIVATE *clp; 390 int cnt; 391 392 clp = CLP(sp); 393 switch (action) { 394 case EX_TERM_SCROLL: 395 /* Move the cursor up one line if that's possible. */ 396 if (clp->cuu1 != NULL) 397 (void)tputs(clp->cuu1, 1, cl_putchar); 398 else if (clp->cup != NULL) 399 (void)tputs(tgoto(clp->cup, 400 0, LINES - 2), 1, cl_putchar); 401 else 402 return (0); 403 /* FALLTHROUGH */ 404 case EX_TERM_CE: 405 /* Clear the line. */ 406 if (clp->el != NULL) { 407 (void)putchar('\r'); 408 (void)tputs(clp->el, 1, cl_putchar); 409 } else { 410 /* 411 * Historically, ex didn't erase the line, so, if the 412 * displayed line was only a single glyph, and <eof> 413 * was more than one glyph, the output would not fully 414 * overwrite the user's input. To fix this, output 415 * the maxiumum character number of spaces. Note, 416 * this won't help if the user entered extra prompt 417 * or <blank> characters before the command character. 418 * We'd have to do a lot of work to make that work, and 419 * it's almost certainly not worth the effort. 420 */ 421 for (cnt = 0; cnt < MAX_CHARACTER_COLUMNS; ++cnt) 422 (void)putchar('\b'); 423 for (cnt = 0; cnt < MAX_CHARACTER_COLUMNS; ++cnt) 424 (void)putchar(' '); 425 (void)putchar('\r'); 426 (void)fflush(stdout); 427 } 428 break; 429 default: 430 abort(); 431 } 432 return (0); 433} 434 435/* 436 * cl_insertln -- 437 * Push down the current line, discarding the bottom line. 438 * 439 * PUBLIC: int cl_insertln(SCR *); 440 */ 441int 442cl_insertln(SCR *sp) 443{ 444 WINDOW *win; 445 win = CLSP(sp) ? CLSP(sp) : stdscr; 446 /* 447 * The current line is expected to be blank after this operation, 448 * and the screen must support that semantic. 449 */ 450 return (winsertln(win) == ERR); 451} 452 453/* 454 * cl_keyval -- 455 * Return the value for a special key. 456 * 457 * PUBLIC: int cl_keyval(SCR *, scr_keyval_t, CHAR_T *, int *); 458 */ 459int 460cl_keyval(SCR *sp, scr_keyval_t val, CHAR_T *chp, int *dnep) 461{ 462 CL_PRIVATE *clp; 463 464 /* 465 * VEOF, VERASE and VKILL are required by POSIX 1003.1-1990, 466 * VWERASE is a 4BSD extension. 467 */ 468 clp = CLP(sp); 469 switch (val) { 470 case KEY_VEOF: 471 *dnep = (*chp = clp->orig.c_cc[VEOF]) == _POSIX_VDISABLE; 472 break; 473 case KEY_VERASE: 474 *dnep = (*chp = clp->orig.c_cc[VERASE]) == _POSIX_VDISABLE; 475 break; 476 case KEY_VKILL: 477 *dnep = (*chp = clp->orig.c_cc[VKILL]) == _POSIX_VDISABLE; 478 break; 479#ifdef VWERASE 480 case KEY_VWERASE: 481 *dnep = (*chp = clp->orig.c_cc[VWERASE]) == _POSIX_VDISABLE; 482 break; 483#endif 484 default: 485 *dnep = 1; 486 break; 487 } 488 return (0); 489} 490 491/* 492 * cl_move -- 493 * Move the cursor. 494 * 495 * PUBLIC: int cl_move(SCR *, size_t, size_t); 496 */ 497int 498cl_move(SCR *sp, size_t lno, size_t cno) 499{ 500 WINDOW *win; 501 win = CLSP(sp) ? CLSP(sp) : stdscr; 502 /* See the comment in cl_cursor. */ 503 if (wmove(win, RLNO(sp, lno), RCNO(sp, cno)) == ERR) { 504 msgq(sp, M_ERR, "Error: move: l(%zu + %zu) c(%zu + %zu)", 505 lno, sp->roff, cno, sp->coff); 506 return (1); 507 } 508 return (0); 509} 510 511/* 512 * cl_refresh -- 513 * Refresh the screen. 514 * 515 * PUBLIC: int cl_refresh(SCR *, int); 516 */ 517int 518cl_refresh(SCR *sp, int repaint) 519{ 520 GS *gp; 521 CL_PRIVATE *clp; 522 WINDOW *win; 523 SCR *psp, *tsp; 524 size_t y, x; 525 526 gp = sp->gp; 527 clp = CLP(sp); 528 win = CLSP(sp) ? CLSP(sp) : stdscr; 529 530 /* 531 * If we received a killer signal, we're done, there's no point 532 * in refreshing the screen. 533 */ 534 if (clp->killersig) 535 return (0); 536 537 /* 538 * If repaint is set, the editor is telling us that we don't know 539 * what's on the screen, so we have to repaint from scratch. 540 * 541 * If repaint set or the screen layout changed, we need to redraw 542 * any lines separating vertically split screens. If the horizontal 543 * offsets are the same, then the split was vertical, and need to 544 * draw a dividing line. 545 */ 546 if (repaint || F_ISSET(clp, CL_LAYOUT)) { 547 getyx(stdscr, y, x); 548 for (psp = sp; psp != NULL; psp = TAILQ_NEXT(psp, q)) 549 for (tsp = TAILQ_NEXT(psp, q); tsp != NULL; 550 tsp = TAILQ_NEXT(tsp, q)) 551 if (psp->roff == tsp->roff) { 552 if (psp->coff + psp->cols + 1 == tsp->coff) 553 cl_rdiv(psp); 554 else 555 if (tsp->coff + tsp->cols + 1 == psp->coff) 556 cl_rdiv(tsp); 557 } 558 (void)wmove(stdscr, y, x); 559 F_CLR(clp, CL_LAYOUT); 560 } 561 562 /* 563 * In the curses library, doing wrefresh(curscr) is okay, but the 564 * screen flashes when we then apply the refresh() to bring it up 565 * to date. So, use clearok(). 566 */ 567 if (repaint) 568 clearok(curscr, 1); 569 /* 570 * Only do an actual refresh, when this is the focus window, 571 * i.e. the one holding the cursor. This assumes that refresh 572 * is called for that window after refreshing the others. 573 * This prevents the cursor being drawn in the other windows. 574 */ 575 return (wnoutrefresh(stdscr) == ERR || 576 wnoutrefresh(win) == ERR || 577 (sp == clp->focus && doupdate() == ERR)); 578} 579 580/* 581 * cl_rdiv -- 582 * Draw a dividing line between two vertically split screens. 583 */ 584static void 585cl_rdiv(SCR *sp) 586{ 587#ifdef __NetBSD__ 588 mvvline(sp->roff, sp->cols + sp->coff, '|', sp->rows); 589#else 590 mvvline(sp->roff, sp->cols + sp->coff, ACS_VLINE, sp->rows); 591#endif 592} 593 594/* 595 * cl_rename -- 596 * Rename the file. 597 * 598 * PUBLIC: int cl_rename(SCR *, char *, int); 599 */ 600int 601cl_rename(SCR *sp, char *name, int on) 602{ 603 GS *gp; 604 CL_PRIVATE *clp; 605 FILE *pfp; 606 char buf[256], *s, *e; 607 char * wid; 608 char cmd[64]; 609 610 gp = sp->gp; 611 clp = CLP(sp); 612 613 /* 614 * XXX 615 * We can only rename windows for xterm. 616 */ 617 if (on) { 618 clp->focus = sp; 619 if (!F_ISSET(clp, CL_RENAME_OK) || 620 strncmp(OG_STR(gp, GO_TERM), "xterm", 5)) 621 return (0); 622 623 if (clp->oname == NULL && (wid = getenv("WINDOWID"))) { 624 snprintf(cmd, sizeof(cmd), "xprop -id %s WM_NAME", wid); 625 if ((pfp = popen(cmd, "r")) == NULL) 626 goto rename; 627 if (fgets(buf, sizeof(buf), pfp) == NULL) { 628 pclose(pfp); 629 goto rename; 630 } 631 pclose(pfp); 632 if ((s = strchr(buf, '"')) != NULL && 633 (e = strrchr(buf, '"')) != NULL) 634 clp->oname = strndup(s + 1, e - s - 1); 635 } 636 637rename: cl_setname(gp, name); 638 639 F_SET(clp, CL_RENAME); 640 } else 641 if (F_ISSET(clp, CL_RENAME)) { 642 cl_setname(gp, clp->oname); 643 644 F_CLR(clp, CL_RENAME); 645 } 646 return (0); 647} 648 649/* 650 * cl_setname -- 651 * Set a X11 icon/window name. 652 * 653 * PUBLIC: void cl_setname(GS *, char *); 654 */ 655void 656cl_setname(GS *gp, char *name) 657{ 658/* X11 xterm escape sequence to rename the icon/window. */ 659#define XTERM_RENAME "\033]0;%s\007" 660 661 (void)printf(XTERM_RENAME, name == NULL ? OG_STR(gp, GO_TERM) : name); 662 (void)fflush(stdout); 663#undef XTERM_RENAME 664} 665 666/* 667 * cl_split -- 668 * Split a screen. 669 * 670 * PUBLIC: int cl_split(SCR *, SCR *); 671 */ 672int 673cl_split(SCR *origp, SCR *newp) 674{ 675 CL_PRIVATE *clp; 676 677 clp = CLP(origp); 678 F_SET(clp, CL_LAYOUT); 679 680 if (CLSP(origp)) 681 delwin(CLSP(origp)); 682 683 origp->cl_private = subwin(stdscr, origp->rows, origp->cols, 684 origp->roff, origp->coff); 685 newp->cl_private = subwin(stdscr, newp->rows, newp->cols, 686 newp->roff, newp->coff); 687 688 /* origp is the original screen, giving up space to newp. */ 689 return (0); 690} 691 692/* 693 * cl_suspend -- 694 * Suspend a screen. 695 * 696 * PUBLIC: int cl_suspend(SCR *, int *); 697 */ 698int 699cl_suspend(SCR *sp, int *allowedp) 700{ 701 struct termios t; 702 CL_PRIVATE *clp; 703 WINDOW *win; 704 GS *gp; 705 size_t y, x; 706 int changed; 707 708 gp = sp->gp; 709 clp = CLP(sp); 710 win = CLSP(sp) ? CLSP(sp) : stdscr; 711 *allowedp = 1; 712 713 /* 714 * The ex implementation of this function isn't needed by screens not 715 * supporting ex commands that require full terminal canonical mode 716 * (e.g. :suspend). 717 * 718 * The vi implementation of this function isn't needed by screens not 719 * supporting vi process suspension, i.e. any screen that isn't backed 720 * by a UNIX shell. 721 * 722 * Setting allowedp to 0 will cause the editor to reject the command. 723 */ 724 if (F_ISSET(sp, SC_EX)) { 725 /* Save the terminal settings, and restore the original ones. */ 726 if (F_ISSET(clp, CL_STDIN_TTY)) { 727 (void)tcgetattr(STDIN_FILENO, &t); 728 (void)tcsetattr(STDIN_FILENO, 729 TCSASOFT | TCSADRAIN, &clp->orig); 730 } 731 732 /* Stop the process group. */ 733 (void)kill(0, SIGTSTP); 734 735 /* Time passes ... */ 736 737 /* Restore terminal settings. */ 738 if (F_ISSET(clp, CL_STDIN_TTY)) 739 (void)tcsetattr(STDIN_FILENO, TCSASOFT | TCSADRAIN, &t); 740 return (0); 741 } 742 743 /* 744 * Move to the lower left-hand corner of the screen. 745 * 746 * XXX 747 * Not sure this is necessary in System V implementations, but it 748 * shouldn't hurt. 749 */ 750 getyx(win, y, x); 751 (void)wmove(win, LINES - 1, 0); 752 (void)wrefresh(win); 753 754 /* 755 * Temporarily end the screen. System V introduced a semantic where 756 * endwin() could be restarted. We use it because restarting curses 757 * from scratch often fails in System V. 4BSD curses didn't support 758 * restarting after endwin(), so we have to do what clean up we can 759 * without calling it. 760 */ 761 /* Save the terminal settings. */ 762 (void)tcgetattr(STDIN_FILENO, &t); 763 764 /* Restore the cursor keys to normal mode. */ 765 (void)keypad(stdscr, FALSE); 766 767 /* Restore the window name. */ 768 (void)cl_rename(sp, NULL, 0); 769 770 (void)endwin(); 771 772 /* 773 * XXX 774 * Restore the original terminal settings. This is bad -- the 775 * reset can cause character loss from the tty queue. However, 776 * we can't call endwin() in BSD curses implementations, and too 777 * many System V curses implementations don't get it right. 778 */ 779 (void)tcsetattr(STDIN_FILENO, TCSADRAIN | TCSASOFT, &clp->orig); 780 781 /* Stop the process group. */ 782 (void)kill(0, SIGTSTP); 783 784 /* Time passes ... */ 785 786 /* 787 * If we received a killer signal, we're done. Leave everything 788 * unchanged. In addition, the terminal has already been reset 789 * correctly, so leave it alone. 790 */ 791 if (clp->killersig) { 792 F_CLR(clp, CL_SCR_EX_INIT | CL_SCR_VI_INIT); 793 return (0); 794 } 795 796 /* Restore terminal settings. */ 797 wrefresh(win); /* Needed on SunOs/Solaris ? */ 798 if (F_ISSET(clp, CL_STDIN_TTY)) 799 (void)tcsetattr(STDIN_FILENO, TCSASOFT | TCSADRAIN, &t); 800 801 /* Set the window name. */ 802 (void)cl_rename(sp, sp->frp->name, 1); 803 804 /* Put the cursor keys into application mode. */ 805 (void)keypad(stdscr, TRUE); 806 807 /* Refresh and repaint the screen. */ 808 (void)wmove(win, y, x); 809 (void)cl_refresh(sp, 1); 810 811 /* If the screen changed size, set the SIGWINCH bit. */ 812 if (cl_ssize(sp, 1, NULL, NULL, &changed)) 813 return (1); 814 if (changed) 815 F_SET(CLP(sp), CL_SIGWINCH); 816 817 return (0); 818} 819 820/* 821 * cl_usage -- 822 * Print out the curses usage messages. 823 * 824 * PUBLIC: void cl_usage(void); 825 */ 826void 827cl_usage(void) 828{ 829#define USAGE "\ 830usage: ex [-eFRrSsv] [-c command] [-t tag] [-w size] [file ...]\n\ 831usage: vi [-eFlRrSv] [-c command] [-t tag] [-w size] [file ...]\n" 832 (void)fprintf(stderr, "%s", USAGE); 833#undef USAGE 834} 835 836#ifdef DEBUG 837/* 838 * gdbrefresh -- 839 * Stub routine so can flush out curses screen changes using gdb. 840 */ 841static int 842 __attribute__((unused)) 843gdbrefresh(void) 844{ 845 refresh(); 846 return (0); /* XXX Convince gdb to run it. */ 847} 848#endif 849