cl/cl_funcs.c

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