diff options
Diffstat (limited to 'display.c')
| -rw-r--r-- | display.c | 4082 |
1 files changed, 4082 insertions, 0 deletions
diff --git a/display.c b/display.c new file mode 100644 index 0000000..978b0a8 --- /dev/null +++ b/display.c @@ -0,0 +1,4082 @@ +/* Copyright (c) 2008, 2009 + * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de) + * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de) + * Micah Cowan (micah@cowan.name) + * Sadrul Habib Chowdhury (sadrul@users.sourceforge.net) + * Copyright (c) 1993-2002, 2003, 2005, 2006, 2007 + * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de) + * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de) + * Copyright (c) 1987 Oliver Laumann + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program (see the file COPYING); if not, see + * https://www.gnu.org/licenses/, or contact Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA + * + **************************************************************** + */ + +#include <sys/types.h> +#include <signal.h> +#include <fcntl.h> +#ifndef sun +# include <sys/ioctl.h> +#endif + +#include "config.h" +#include "screen.h" +#include "extern.h" +#include "braille.h" +#include "canvas.h" + +/* CSI parsing status */ +enum + { + CSI_PB=0, CSI_PX=1, CSI_PY=2, CSI_DONE=3, + CSI_ESC_SEEN, CSI_BEGIN, CSI_INACTIVE, CSI_INVALID + }; + +static int CountChars __P((int)); +static int DoAddChar __P((int)); +static int BlankResize __P((int, int)); +static int CallRewrite __P((int, int, int, int)); +static void disp_readev_fn __P((struct event *, char *)); +static void disp_processinput __P((struct display *, unsigned char *, int)); +static void disp_writeev_fn __P((struct event *, char *)); +#ifdef linux +static void disp_writeev_eagain __P((struct event *, char *)); +#endif +static void disp_status_fn __P((struct event *, char *)); +static void disp_hstatus_fn __P((struct event *, char *)); +static void disp_blocked_fn __P((struct event *, char *)); +#ifdef MAPKEYS +static void disp_map_fn __P((struct event *, char *)); +#endif +static void disp_idle_fn __P((struct event *, char *)); +#ifdef BLANKER_PRG +static void disp_blanker_fn __P((struct event *, char *)); +#endif +static void WriteLP __P((int, int)); +static void INSERTCHAR __P((int)); +static void RAW_PUTCHAR __P((int)); +#ifdef COLOR +static void SetBackColor __P((int)); +#endif +static void RemoveStatusMinWait __P((void)); + + +extern struct layer *flayer; +extern struct win *windows, *fore; +extern struct LayFuncs WinLf; + +extern int use_hardstatus; +extern int MsgWait, MsgMinWait; +extern const int Z0width, Z1width; +extern unsigned char *blank, *null; +extern struct mline mline_blank, mline_null, mline_old; +extern struct mchar mchar_null, mchar_blank, mchar_so; +extern struct NewWindow nwin_default; +extern struct action idleaction; + +/* XXX shouldn't be here */ +extern char *hstatusstring; +extern char *captionstring; + +extern int pastefont; +extern int idletimo; + +#ifdef BLANKER_PRG +extern int pty_preopen; +#if defined(TIOCSWINSZ) || defined(TIOCGWINSZ) +extern struct winsize glwz; +#endif +extern char **NewEnv; +extern int real_uid, real_gid; +extern int ServerSocket, eff_uid, eff_gid; +#endif + +/* + * tputs needs this to calculate the padding + */ +#ifndef NEED_OSPEED +extern +#endif /* NEED_OSPEED */ +short ospeed; + + +struct display *display, *displays; +#ifdef COLOR +int attr2color[8][4]; +int nattr2color; +#endif + +#ifndef MULTI +struct display TheDisplay; +#endif + +/* + * The default values + */ +int defobuflimit = OBUF_MAX; +int defnonblock = -1; +int defmousetrack = 0; +#ifdef AUTO_NUKE +int defautonuke = 0; +#endif +int captionalways; +int hardstatusemu = HSTATUS_IGNORE; + +int focusminwidth, focusminheight; + +/* + * Default layer management + */ + +void +DefProcess(bufp, lenp) +char **bufp; +int *lenp; +{ + *bufp += *lenp; + *lenp = 0; +} + +void +DefRedisplayLine(y, xs, xe, isblank) +int y, xs, xe, isblank; +{ + if (isblank == 0 && y >= 0) + DefClearLine(y, xs, xe, 0); +} + +void +DefClearLine(y, xs, xe, bce) +int y, xs, xe, bce; +{ + LClearLine(flayer, y, xs, xe, bce, (struct mline *)0); +} + +/*ARGSUSED*/ +int +DefRewrite(y, xs, xe, rend, doit) +int y, xs, xe, doit; +struct mchar *rend; +{ + return EXPENSIVE; +} + +/*ARGSUSED*/ +int +DefResize(wi, he) +int wi, he; +{ + return -1; +} + +void +DefRestore() +{ + LAY_DISPLAYS(flayer, InsertMode(0)); + /* ChangeScrollRegion(0, D_height - 1); */ + LKeypadMode(flayer, 0); + LCursorkeysMode(flayer, 0); + LCursorVisibility(flayer, 0); + LMouseMode(flayer, 0); + LSetRendition(flayer, &mchar_null); + LSetFlow(flayer, nwin_default.flowflag & FLOW_NOW); +} + +/* + * Blank layer management + */ + +struct LayFuncs BlankLf = +{ + DefProcess, + 0, + DefRedisplayLine, + DefClearLine, + DefRewrite, + BlankResize, + DefRestore, + 0 +}; + +/*ARGSUSED*/ +static int +BlankResize(wi, he) +int wi, he; +{ + flayer->l_width = wi; + flayer->l_height = he; + return 0; +} + + +/* + * Generate new display, start with a blank layer. + * The termcap arrays are not initialised here. + * The new display is placed in the displays list. + */ + +struct display * +MakeDisplay(uname, utty, term, fd, pid, Mode) +char *uname, *utty, *term; +int fd, pid; +struct mode *Mode; +{ + struct acluser **u; + struct baud_values *b; + + if (!*(u = FindUserPtr(uname)) && UserAdd(uname, (char *)0, u)) + return 0; /* could not find or add user */ + +#ifdef MULTI + if ((display = (struct display *)calloc(1, sizeof(*display))) == 0) + return 0; +#else + if (displays) + return 0; + bzero((char *)&TheDisplay, sizeof(TheDisplay)); + display = &TheDisplay; +#endif + display->d_next = displays; + displays = display; + D_flow = 1; + D_nonblock = defnonblock; + D_userfd = fd; + D_readev.fd = D_writeev.fd = fd; + D_readev.type = EV_READ; + D_writeev.type = EV_WRITE; + D_readev.data = D_writeev.data = (char *)display; + D_readev.handler = disp_readev_fn; + D_writeev.handler = disp_writeev_fn; + evenq(&D_readev); + D_writeev.condpos = &D_obuflen; + D_writeev.condneg = &D_obuffree; + evenq(&D_writeev); + D_statusev.type = EV_TIMEOUT; + D_statusev.data = (char *)display; + D_statusev.handler = disp_status_fn; + D_hstatusev.type = EV_TIMEOUT; + D_hstatusev.data = (char *)display; + D_hstatusev.handler = disp_hstatus_fn; + D_blockedev.type = EV_TIMEOUT; + D_blockedev.data = (char *)display; + D_blockedev.handler = disp_blocked_fn; + D_blockedev.condpos = &D_obuffree; + D_blockedev.condneg = &D_obuflenmax; + D_hstatusev.handler = disp_hstatus_fn; +#ifdef MAPKEYS + D_mapev.type = EV_TIMEOUT; + D_mapev.data = (char *)display; + D_mapev.handler = disp_map_fn; +#endif + D_idleev.type = EV_TIMEOUT; + D_idleev.data = (char *)display; + D_idleev.handler = disp_idle_fn; +#ifdef BLANKER_PRG + D_blankerev.type = EV_READ; + D_blankerev.data = (char *)display; + D_blankerev.handler = disp_blanker_fn; + D_blankerev.fd = -1; +#endif + D_OldMode = *Mode; + D_status_obuffree = -1; + Resize_obuf(); /* Allocate memory for buffer */ + D_obufmax = defobuflimit; + D_obuflenmax = D_obuflen - D_obufmax; +#ifdef AUTO_NUKE + D_auto_nuke = defautonuke; +#endif + D_obufp = D_obuf; + D_printfd = -1; + D_userpid = pid; + +#ifdef POSIX + if ((b = lookup_baud((int)cfgetospeed(&D_OldMode.tio)))) + D_dospeed = b->idx; +#else +# ifdef TERMIO + if ((b = lookup_baud(D_OldMode.tio.c_cflag & CBAUD))) + D_dospeed = b->idx; +# else + D_dospeed = (short)D_OldMode.m_ttyb.sg_ospeed; +# endif +#endif + debug1("New displays ospeed = %d\n", D_dospeed); + + strncpy(D_usertty, utty, sizeof(D_usertty) - 1); + D_usertty[sizeof(D_usertty) - 1] = 0; + strncpy(D_termname, term, MAXTERMLEN); + D_termname[MAXTERMLEN] = 0; + D_user = *u; + D_processinput = ProcessInput; + D_mousetrack = defmousetrack; + return display; +} + + +void +FreeDisplay() +{ + struct win *p; +#ifdef MULTI + struct display *d, **dp; +#endif + +#ifdef FONT + FreeTransTable(); +#endif +#ifdef BLANKER_PRG + KillBlanker(); +#endif + if (D_userfd >= 0) + { + Flush(3); + if (!display) + return; + SetTTY(D_userfd, &D_OldMode); + fcntl(D_userfd, F_SETFL, 0); + } + freetty(); + if (D_tentry) + free(D_tentry); + D_tentry = 0; + if (D_processinputdata) + free(D_processinputdata); + D_processinputdata = 0; + D_tcinited = 0; + evdeq(&D_hstatusev); + evdeq(&D_statusev); + evdeq(&D_readev); + evdeq(&D_writeev); + evdeq(&D_blockedev); +#ifdef MAPKEYS + evdeq(&D_mapev); + if (D_kmaps) + { + free(D_kmaps); + D_kmaps = 0; + D_aseqs = 0; + D_nseqs = 0; + D_seqp = 0; + D_seql = 0; + D_seqh = 0; + } +#endif + evdeq(&D_idleev); +#ifdef BLANKER_PRG + evdeq(&D_blankerev); +#endif +#ifdef HAVE_BRAILLE + if (bd.bd_dpy == display) + { + bd.bd_start_braille = 0; + StartBraille(); + } +#endif + +#ifdef MULTI + for (dp = &displays; (d = *dp) ; dp = &d->d_next) + if (d == display) + break; + ASSERT(d); + if (D_status_lastmsg) + free(D_status_lastmsg); + if (D_obuf) + free(D_obuf); + *dp = display->d_next; +#else /* MULTI */ + ASSERT(display == displays); + ASSERT(display == &TheDisplay); + displays = 0; +#endif /* MULTI */ + + while (D_canvas.c_slperp) + FreeCanvas(D_canvas.c_slperp); + D_cvlist = 0; + + for (p = windows; p; p = p->w_next) + { + if (p->w_pdisplay == display) + p->w_pdisplay = 0; + if (p->w_lastdisp == display) + p->w_lastdisp = 0; + if (p->w_readev.condneg == &D_status || p->w_readev.condneg == &D_obuflenmax) + p->w_readev.condpos = p->w_readev.condneg = 0; + } +#ifdef ZMODEM + for (p = windows; p; p = p->w_next) + if (p->w_zdisplay == display) + zmodem_abort(p, 0); +#endif + if (D_mousetrack) + { + D_mousetrack = 0; + MouseMode(0); + } +#ifdef MULTI + free((char *)display); +#endif + display = 0; +} + +/* + * if the adaptflag is on, we keep the size of this display, else + * we may try to restore our old window sizes. + */ +void +InitTerm(adapt) +int adapt; +{ + ASSERT(display); + ASSERT(D_tcinited); + D_top = D_bot = -1; + AddCStr(D_IS); + AddCStr(D_TI); + /* Check for toggle */ + if (D_IM && strcmp(D_IM, D_EI)) + AddCStr(D_EI); + D_insert = 0; +#ifdef MAPKEYS + AddCStr(D_KS); + AddCStr(D_CCS); +#else + /* Check for toggle */ + if (D_KS && strcmp(D_KS, D_KE)) + AddCStr(D_KE); + if (D_CCS && strcmp(D_CCS, D_CCE)) + AddCStr(D_CCE); +#endif + D_keypad = 0; + D_cursorkeys = 0; + AddCStr(D_ME); + AddCStr(D_EA); + AddCStr(D_CE0); + D_rend = mchar_null; + D_atyp = 0; + if (adapt == 0) + ResizeDisplay(D_defwidth, D_defheight); + ChangeScrollRegion(0, D_height - 1); + D_x = D_y = 0; + Flush(3); + ClearAll(); + debug1("we %swant to adapt all our windows to the display\n", + (adapt) ? "" : "don't "); + /* In case the size was changed by a init sequence */ + CheckScreenSize((adapt) ? 2 : 0); +} + +void +FinitTerm() +{ + ASSERT(display); +#ifdef BLANKER_PRG + KillBlanker(); +#endif + if (D_tcinited) + { + ResizeDisplay(D_defwidth, D_defheight); + InsertMode(0); + ChangeScrollRegion(0, D_height - 1); + KeypadMode(0); + CursorkeysMode(0); + CursorVisibility(0); + if (D_mousetrack) + D_mousetrack = 0; + MouseMode(0); + ExtMouseMode(0); + SetRendition(&mchar_null); + SetFlow(FLOW_NOW); +#ifdef MAPKEYS + AddCStr(D_KE); + AddCStr(D_CCE); +#endif + if (D_hstatus) + ShowHStatus((char *)0); +#ifdef RXVT_OSC + ClearAllXtermOSC(); +#endif + D_x = D_y = -1; + GotoPos(0, D_height - 1); + AddChar('\r'); + AddChar('\n'); + AddCStr(D_TE); + } + Flush(3); +} + + +static void +INSERTCHAR(c) +int c; +{ + ASSERT(display); + if (!D_insert && D_x < D_width - 1) + { + if (D_IC || D_CIC) + { + if (D_IC) + AddCStr(D_IC); + else + AddCStr2(D_CIC, 1); + RAW_PUTCHAR(c); + return; + } + InsertMode(1); + if (!D_insert) + { + RefreshLine(D_y, D_x, D_width-1, 0); + return; + } + } + RAW_PUTCHAR(c); +} + +void +PUTCHAR(c) +int c; +{ + ASSERT(display); + if (D_insert && D_x < D_width - 1) + InsertMode(0); + RAW_PUTCHAR(c); +} + +void +PUTCHARLP(c) +int c; +{ + if (D_x < D_width - 1) + { + if (D_insert) + InsertMode(0); + RAW_PUTCHAR(c); + return; + } + if (D_CLP || D_y != D_bot) + { + int y = D_y; + RAW_PUTCHAR(c); + if (D_AM && !D_CLP) + GotoPos(D_width - 1, y); + return; + } + debug("PUTCHARLP: lp_missing!\n"); + D_lp_missing = 1; + D_rend.image = c; + D_lpchar = D_rend; +#ifdef DW_CHARS + /* XXX -> PutChar ? */ + if (D_mbcs) + { + D_lpchar.mbcs = c; + D_lpchar.image = D_mbcs; + D_mbcs = 0; + D_x--; + } +#endif +} + +/* + * RAW_PUTCHAR() is for all text that will be displayed. + * NOTE: charset Nr. 0 has a conversion table, but c1, c2, ... don't. + */ + +STATIC void +RAW_PUTCHAR(c) +int c; +{ + ASSERT(display); + +#ifdef FONT +# ifdef UTF8 + if (D_encoding == UTF8) + { + c = (c & 255) | (unsigned char)D_rend.font << 8 | (unsigned char)D_rend.fontx << 16; +# ifdef DW_CHARS + if (D_mbcs) + { + c = D_mbcs; + if (D_x == D_width) + D_x += D_AM ? 1 : -1; + D_mbcs = 0; + } + else if (utf8_isdouble(c)) + { + D_mbcs = c; + D_x++; + return; + } +# endif + if (c < 32) + { + AddCStr2(D_CS0, '0'); + AddChar(c + 0x5f); + AddCStr(D_CE0); + goto addedutf8; + } + if (c < 0x80) + { + if (D_xtable && D_xtable[(int)(unsigned char)D_rend.font] && D_xtable[(int)(unsigned char)D_rend.font][(int)(unsigned char)c]) + AddStr(D_xtable[(int)(unsigned char)D_rend.font][(int)(unsigned char)c]); + else + AddChar(c); + } + else + AddUtf8(c); + goto addedutf8; + } +# endif +# ifdef DW_CHARS + if (is_dw_font(D_rend.font)) + { + int t = c; + if (D_mbcs == 0) + { + D_mbcs = c; + D_x++; + return; + } + D_x--; + if (D_x == D_width - 1) + D_x += D_AM ? 1 : -1; + c = D_mbcs; + D_mbcs = t; + } +# endif +# if defined(ENCODINGS) && defined(DW_CHARS) + if (D_encoding) + c = PrepareEncodedChar(c); +# endif +# ifdef DW_CHARS + kanjiloop: +# endif + if (D_xtable && D_xtable[(int)(unsigned char)D_rend.font] && D_xtable[(int)(unsigned char)D_rend.font][(int)(unsigned char)c]) + AddStr(D_xtable[(int)(unsigned char)D_rend.font][(int)(unsigned char)c]); + else + AddChar(D_rend.font != '0' ? c : D_c0_tab[(int)(unsigned char)c]); +#else /* FONT */ + AddChar(c); +#endif /* FONT */ + +#ifdef UTF8 +addedutf8: +#endif + if (++D_x >= D_width) + { + if (D_AM == 0) + D_x = D_width - 1; + else if (!D_CLP || D_x > D_width) + { + D_x -= D_width; + if (D_y < D_height-1 && D_y != D_bot) + D_y++; + } + } +#ifdef DW_CHARS + if (D_mbcs) + { + c = D_mbcs; + D_mbcs = 0; + goto kanjiloop; + } +#endif +} + +static int +DoAddChar(c) +int c; +{ + /* this is for ESC-sequences only (AddChar is a macro) */ + AddChar(c); + return c; +} + +void +AddCStr(s) +char *s; +{ + if (display && s && *s) + { + ospeed = D_dospeed; + tputs(s, 1, DoAddChar); + } +} + +void +AddCStr2(s, c) +char *s; +int c; +{ + if (display && s && *s) + { + ospeed = D_dospeed; + tputs(tgoto(s, 0, c), 1, DoAddChar); + } +} + + +/* Insert mode is a toggle on some terminals, so we need this hack: + */ +void +InsertMode(on) +int on; +{ + if (display && on != D_insert && D_IM) + { + D_insert = on; + if (on) + AddCStr(D_IM); + else + AddCStr(D_EI); + } +} + +/* ...and maybe keypad application mode is a toggle, too: + */ +void +KeypadMode(on) +int on; +{ +#ifdef MAPKEYS + if (display) + D_keypad = on; +#else + if (display && D_keypad != on && D_KS) + { + D_keypad = on; + if (on) + AddCStr(D_KS); + else + AddCStr(D_KE); + } +#endif +} + +void +CursorkeysMode(on) +int on; +{ +#ifdef MAPKEYS + if (display) + D_cursorkeys = on; +#else + if (display && D_cursorkeys != on && D_CCS) + { + D_cursorkeys = on; + if (on) + AddCStr(D_CCS); + else + AddCStr(D_CCE); + } +#endif +} + +void +ReverseVideo(on) +int on; +{ + if (display && D_revvid != on && D_CVR) + { + D_revvid = on; + if (D_revvid) + AddCStr(D_CVR); + else + AddCStr(D_CVN); + } +} + +void +CursorVisibility(v) +int v; +{ + if (display && D_curvis != v) + { + if (D_curvis) + AddCStr(D_VE); /* do this always, just to be safe */ + D_curvis = 0; + if (v == -1 && D_VI) + AddCStr(D_VI); + else if (v == 1 && D_VS) + AddCStr(D_VS); + else + return; + D_curvis = v; + } +} + +void +MouseMode(mode) +int mode; +{ + if (!display) + return; + + if (mode < D_mousetrack) + mode = D_mousetrack; + + if (D_mouse != mode) + { + char mousebuf[20]; + if (!D_CXT) + return; + if (D_mouse) + { + sprintf(mousebuf, "\033[?%dl", D_mouse); + AddStr(mousebuf); + } + if (mode) + { + sprintf(mousebuf, "\033[?%dh", mode); + AddStr(mousebuf); + } + D_mouse = mode; + D_mouse_parse.state = CSI_INACTIVE; + } +} + +void +ExtMouseMode(mode) + int mode; +{ + if (display && D_extmouse != mode) + { + char mousebuf[20]; + if (!D_CXT) + return; + if (D_extmouse) + { + sprintf(mousebuf, "\033[?%dl", D_extmouse); + AddStr(mousebuf); + } + if (mode) + { + sprintf(mousebuf, "\033[?%dh", mode); + AddStr(mousebuf); + } + D_extmouse = mode; + D_mouse_parse.state = CSI_INACTIVE; + } +} + +static int StrCost; + +/* ARGSUSED */ +static int +CountChars(c) +int c; +{ + StrCost++; + return c; +} + +int +CalcCost(s) +register char *s; +{ + ASSERT(display); + if (s) + { + StrCost = 0; + ospeed = D_dospeed; + tputs(s, 1, CountChars); + return StrCost; + } + else + return EXPENSIVE; +} + +static int +CallRewrite(y, xs, xe, doit) +int y, xs, xe, doit; +{ + struct canvas *cv, *cvlist, *cvlnext; + struct viewport *vp; + struct layer *oldflayer; + int cost; + + debug3("CallRewrite %d %d %d\n", y, xs, xe); + ASSERT(display); + ASSERT(xe >= xs); + + vp = 0; + for (cv = D_cvlist; cv; cv = cv->c_next) + { + if (y < cv->c_ys || y > cv->c_ye || xe < cv->c_xs || xs > cv->c_xe) + continue; + for (vp = cv->c_vplist; vp; vp = vp->v_next) + if (y >= vp->v_ys && y <= vp->v_ye && xe >= vp->v_xs && xs <= vp->v_xe) + break; + if (vp) + break; + } + if (doit) + { + oldflayer = flayer; + flayer = cv->c_layer; + cvlist = flayer->l_cvlist; + cvlnext = cv->c_lnext; + flayer->l_cvlist = cv; + cv->c_lnext = 0; + LayRewrite(y - vp->v_yoff, xs - vp->v_xoff, xe - vp->v_xoff, &D_rend, 1); + flayer->l_cvlist = cvlist; + cv->c_lnext = cvlnext; + flayer = oldflayer; + return 0; + } + if (cv == 0 || cv->c_layer == 0) + return EXPENSIVE; /* not found or nothing on it */ + if (xs < vp->v_xs || xe > vp->v_xe) + return EXPENSIVE; /* crosses viewport boundaries */ + if (y - vp->v_yoff < 0 || y - vp->v_yoff >= cv->c_layer->l_height) + return EXPENSIVE; /* line not on layer */ + if (xs - vp->v_xoff < 0 || xe - vp->v_xoff >= cv->c_layer->l_width) + return EXPENSIVE; /* line not on layer */ +#ifdef UTF8 + if (D_encoding == UTF8) + D_rend.font = 0; +#endif + oldflayer = flayer; + flayer = cv->c_layer; + debug3("Calling Rewrite %d %d %d\n", y - vp->v_yoff, xs - vp->v_xoff, xe - vp->v_xoff); + cost = LayRewrite(y - vp->v_yoff, xs - vp->v_xoff, xe - vp->v_xoff, &D_rend, 0); + flayer = oldflayer; + if (D_insert) + cost += D_EIcost + D_IMcost; + return cost; +} + + +void +GotoPos(x2, y2) +int x2, y2; +{ + register int dy, dx, x1, y1; + register int costx, costy; + register int m; + register char *s; + int CMcost; + enum move_t xm = M_NONE, ym = M_NONE; + + if (!display) + return; + + x1 = D_x; + y1 = D_y; + + if (x1 == D_width) + { + if (D_CLP && D_AM) + x1 = -1; /* don't know how the terminal treats this */ + else + x1--; + } + if (x2 == D_width) + x2--; + dx = x2 - x1; + dy = y2 - y1; + if (dy == 0 && dx == 0) + return; + debug2("GotoPos (%d,%d)", x1, y1); + debug2(" -> (%d,%d)\n", x2, y2); + if (!D_MS) /* Safe to move ? */ + SetRendition(&mchar_null); + if (y1 < 0 /* don't know the y position */ + || (y2 > D_bot && y1 <= D_bot) /* have to cross border */ + || (y2 < D_top && y1 >= D_top)) /* of scrollregion ? */ + { + DoCM: + if (D_HO && !x2 && !y2) + AddCStr(D_HO); + else + AddCStr(tgoto(D_CM, x2, y2)); + D_x = x2; + D_y = y2; + return; + } + + /* some scrollregion implementations don't allow movements + * away from the region. sigh. + */ + if ((y1 > D_bot && y2 > y1) || (y1 < D_top && y2 < y1)) + goto DoCM; + + /* Calculate CMcost */ + if (D_HO && !x2 && !y2) + s = D_HO; + else + s = tgoto(D_CM, x2, y2); + CMcost = CalcCost(s); + + /* Calculate the cost to move the cursor to the right x position */ + costx = EXPENSIVE; + if (x1 >= 0) /* relativ x positioning only if we know where we are */ + { + if (dx > 0) + { + if (D_CRI && (dx > 1 || !D_ND)) + { + costx = CalcCost(tgoto(D_CRI, 0, dx)); + xm = M_CRI; + } + if ((m = D_NDcost * dx) < costx) + { + costx = m; + xm = M_RI; + } + /* Speedup: dx <= LayRewrite() */ + if (dx < costx && (m = CallRewrite(y1, x1, x2 - 1, 0)) < costx) + { + costx = m; + xm = M_RW; + } + } + else if (dx < 0) + { + if (D_CLE && (dx < -1 || !D_BC)) + { + costx = CalcCost(tgoto(D_CLE, 0, -dx)); + xm = M_CLE; + } + if ((m = -dx * D_LEcost) < costx) + { + costx = m; + xm = M_LE; + } + } + else + costx = 0; + } + /* Speedup: LayRewrite() >= x2 */ + if (x2 + D_CRcost < costx && (m = (x2 ? CallRewrite(y1, 0, x2 - 1, 0) : 0) + D_CRcost) < costx) + { + costx = m; + xm = M_CR; + } + + /* Check if it is already cheaper to do CM */ + if (costx >= CMcost) + goto DoCM; + + /* Calculate the cost to move the cursor to the right y position */ + costy = EXPENSIVE; + if (dy > 0) + { + if (D_CDO && dy > 1) /* DO & NL are always != 0 */ + { + costy = CalcCost(tgoto(D_CDO, 0, dy)); + ym = M_CDO; + } + if ((m = dy * ((x2 == 0) ? D_NLcost : D_DOcost)) < costy) + { + costy = m; + ym = M_DO; + } + } + else if (dy < 0) + { + if (D_CUP && (dy < -1 || !D_UP)) + { + costy = CalcCost(tgoto(D_CUP, 0, -dy)); + ym = M_CUP; + } + if ((m = -dy * D_UPcost) < costy) + { + costy = m; + ym = M_UP; + } + } + else + costy = 0; + + /* Finally check if it is cheaper to do CM */ + if (costx + costy >= CMcost) + goto DoCM; + + switch (xm) + { + case M_LE: + while (dx++ < 0) + AddCStr(D_BC); + break; + case M_CLE: + AddCStr2(D_CLE, -dx); + break; + case M_RI: + while (dx-- > 0) + AddCStr(D_ND); + break; + case M_CRI: + AddCStr2(D_CRI, dx); + break; + case M_CR: + AddCStr(D_CR); + D_x = 0; + x1 = 0; + /* FALLTHROUGH */ + case M_RW: + if (x1 < x2) + (void) CallRewrite(y1, x1, x2 - 1, 1); + break; + default: + break; + } + + switch (ym) + { + case M_UP: + while (dy++ < 0) + AddCStr(D_UP); + break; + case M_CUP: + AddCStr2(D_CUP, -dy); + break; + case M_DO: + s = (x2 == 0) ? D_NL : D_DO; + while (dy-- > 0) + AddCStr(s); + break; + case M_CDO: + AddCStr2(D_CDO, dy); + break; + default: + break; + } + D_x = x2; + D_y = y2; +} + +void +ClearAll() +{ + ASSERT(display); + ClearArea(0, 0, 0, D_width - 1, D_width - 1, D_height - 1, 0, 0); +} + +void +ClearArea(x1, y1, xs, xe, x2, y2, bce, uselayfn) +int x1, y1, xs, xe, x2, y2, bce, uselayfn; +{ + int y, xxe; + struct canvas *cv; + struct viewport *vp; + + debug2("Clear %d,%d", x1, y1); + debug2(" %d-%d", xs, xe); + debug2(" %d,%d", x2, y2); + debug2(" uselayfn=%d bce=%d\n", uselayfn, bce); + ASSERT(display); + if (x1 == D_width) + x1--; + if (x2 == D_width) + x2--; + if (xs == -1) + xs = x1; + if (xe == -1) + xe = x2; + if (D_UT) /* Safe to erase ? */ + SetRendition(&mchar_null); +#ifdef COLOR + if (D_BE) + SetBackColor(bce); +#endif + if (D_lp_missing && y1 <= D_bot && xe >= D_width - 1) + { + if (y2 > D_bot || (y2 == D_bot && x2 >= D_width - 1)) + D_lp_missing = 0; + } + if (x2 == D_width - 1 && (xs == 0 || y1 == y2) && xe == D_width - 1 && y2 == D_height - 1 && (!bce || D_BE)) + { +#ifdef AUTO_NUKE + if (x1 == 0 && y1 == 0 && D_auto_nuke) + NukePending(); +#endif + if (x1 == 0 && y1 == 0 && D_CL) + { + AddCStr(D_CL); + D_y = D_x = 0; + return; + } + /* + * Workaround a hp700/22 terminal bug. Do not use CD where CE + * is also appropriate. + */ + if (D_CD && (y1 < y2 || !D_CE)) + { + GotoPos(x1, y1); + AddCStr(D_CD); + return; + } + } + if (x1 == 0 && xs == 0 && (xe == D_width - 1 || y1 == y2) && y1 == 0 && D_CCD && (!bce || D_BE)) + { + GotoPos(x1, y1); + AddCStr(D_CCD); + return; + } + xxe = xe; + for (y = y1; y <= y2; y++, x1 = xs) + { + if (y == y2) + xxe = x2; + if (x1 == 0 && D_CB && (xxe != D_width - 1 || (D_x == xxe && D_y == y)) && (!bce || D_BE)) + { + GotoPos(xxe, y); + AddCStr(D_CB); + continue; + } + if (xxe == D_width - 1 && D_CE && (!bce || D_BE)) + { + GotoPos(x1, y); + AddCStr(D_CE); + continue; + } + if (uselayfn) + { + vp = 0; + for (cv = D_cvlist; cv; cv = cv->c_next) + { + if (y < cv->c_ys || y > cv->c_ye || xxe < cv->c_xs || x1 > cv->c_xe) + continue; + for (vp = cv->c_vplist; vp; vp = vp->v_next) + if (y >= vp->v_ys && y <= vp->v_ye && xxe >= vp->v_xs && x1 <= vp->v_xe) + break; + if (vp) + break; + } + if (cv && cv->c_layer && x1 >= vp->v_xs && xxe <= vp->v_xe && + y - vp->v_yoff >= 0 && y - vp->v_yoff < cv->c_layer->l_height && + xxe - vp->v_xoff >= 0 && x1 - vp->v_xoff < cv->c_layer->l_width) + { + struct layer *oldflayer = flayer; + struct canvas *cvlist, *cvlnext; + flayer = cv->c_layer; + cvlist = flayer->l_cvlist; + cvlnext = cv->c_lnext; + flayer->l_cvlist = cv; + cv->c_lnext = 0; + LayClearLine(y - vp->v_yoff, x1 - vp->v_xoff, xxe - vp->v_xoff, bce); + flayer->l_cvlist = cvlist; + cv->c_lnext = cvlnext; + flayer = oldflayer; + continue; + } + } + ClearLine((struct mline *)0, y, x1, xxe, bce); + } +} + + +/* + * if cur_only > 0, we only redisplay current line, as a full refresh is + * too expensive over a low baud line. + */ +void +Redisplay(cur_only) +int cur_only; +{ + ASSERT(display); + + /* XXX do em all? */ + InsertMode(0); + ChangeScrollRegion(0, D_height - 1); + KeypadMode(0); + CursorkeysMode(0); + CursorVisibility(0); + MouseMode(0); + ExtMouseMode(0); + SetRendition(&mchar_null); + SetFlow(FLOW_NOW); + + ClearAll(); +#ifdef RXVT_OSC + RefreshXtermOSC(); +#endif + if (cur_only > 0 && D_fore) + RefreshArea(0, D_fore->w_y, D_width - 1, D_fore->w_y, 1); + else + RefreshAll(1); + RefreshHStatus(); + CV_CALL(D_forecv, LayRestore();LaySetCursor()); +} + +void +RedisplayDisplays(cur_only) +int cur_only; +{ + struct display *olddisplay = display; + for (display = displays; display; display = display->d_next) + Redisplay(cur_only); + display = olddisplay; +} + + +/* XXX: use oml! */ +void +ScrollH(y, xs, xe, n, bce, oml) +int y, xs, xe, n, bce; +struct mline *oml; +{ + int i; + + if (n == 0) + return; + if (xe != D_width - 1) + { + RefreshLine(y, xs, xe, 0); + /* UpdateLine(oml, y, xs, xe); */ + return; + } + GotoPos(xs, y); + if (D_UT) + SetRendition(&mchar_null); +#ifdef COLOR + if (D_BE) + SetBackColor(bce); +#endif + if (n > 0) + { + if (n >= xe - xs + 1) + n = xe - xs + 1; + if (D_CDC && !(n == 1 && D_DC)) + AddCStr2(D_CDC, n); + else if (D_DC) + { + for (i = n; i--; ) + AddCStr(D_DC); + } + else + { + RefreshLine(y, xs, xe, 0); + /* UpdateLine(oml, y, xs, xe); */ + return; + } + } + else + { + if (-n >= xe - xs + 1) + n = -(xe - xs + 1); + if (!D_insert) + { + if (D_CIC && !(n == -1 && D_IC)) + AddCStr2(D_CIC, -n); + else if (D_IC) + { + for (i = -n; i--; ) + AddCStr(D_IC); + } + else if (D_IM) + { + InsertMode(1); + SetRendition(&mchar_null); +#ifdef COLOR + SetBackColor(bce); +#endif + for (i = -n; i--; ) + INSERTCHAR(' '); + bce = 0; /* all done */ + } + else + { + /* UpdateLine(oml, y, xs, xe); */ + RefreshLine(y, xs, xe, 0); + return; + } + } + else + { + SetRendition(&mchar_null); +#ifdef COLOR + SetBackColor(bce); +#endif + for (i = -n; i--; ) + INSERTCHAR(' '); + bce = 0; /* all done */ + } + } + if (bce && !D_BE) + { + if (n > 0) + ClearLine((struct mline *)0, y, xe - n + 1, xe, bce); + else + ClearLine((struct mline *)0, y, xs, xs - n - 1, bce); + } + if (D_lp_missing && y == D_bot) + { + if (n > 0) + WriteLP(D_width - 1 - n, y); + D_lp_missing = 0; + } +} + +void +ScrollV(xs, ys, xe, ye, n, bce) +int xs, ys, xe, ye, n, bce; +{ + int i; + int up; + int oldbot; + int alok, dlok, aldlfaster; + int missy = 0; + + ASSERT(display); + if (n == 0) + return; + if (n >= ye - ys + 1 || -n >= ye - ys + 1) + { + ClearArea(xs, ys, xs, xe, xe, ye, bce, 0); + return; + } + if (xs > D_vpxmin || xe < D_vpxmax) + { + RefreshArea(xs, ys, xe, ye, 0); + return; + } + + if (D_lp_missing) + { + if (D_bot > ye || D_bot < ys) + missy = D_bot; + else + { + missy = D_bot - n; + if (missy > ye || missy < ys) + D_lp_missing = 0; + } + } + + up = 1; + if (n < 0) + { + up = 0; + n = -n; + } + if (n >= ye - ys + 1) + n = ye - ys + 1; + + oldbot = D_bot; + if (ys < D_top || D_bot != ye) + ChangeScrollRegion(ys, ye); + alok = (D_AL || D_CAL || (ys >= D_top && ye == D_bot && up)); + dlok = (D_DL || D_CDL || (ys >= D_top && ye == D_bot && !up)); + if (D_top != ys && !(alok && dlok)) + ChangeScrollRegion(ys, ye); + + if (D_lp_missing && + (oldbot != D_bot || + (oldbot == D_bot && up && D_top == ys && D_bot == ye))) + { + WriteLP(D_width - 1, oldbot); + if (oldbot == D_bot) /* have scrolled */ + { + if (--n == 0) + { +/* XXX + ChangeScrollRegion(oldtop, oldbot); +*/ + if (bce && !D_BE) + ClearLine((struct mline *)0, ye, xs, xe, bce); + return; + } + } + } + + if (D_UT) + SetRendition(&mchar_null); +#ifdef COLOR + if (D_BE) + SetBackColor(bce); +#endif + + aldlfaster = (n > 1 && ys >= D_top && ye == D_bot && ((up && D_CDL) || (!up && D_CAL))); + + if ((up || D_SR) && D_top == ys && D_bot == ye && !aldlfaster) + { + if (up) + { + GotoPos(0, ye); + for(i = n; i-- > 0; ) + AddCStr(D_NL); /* was SF, I think NL is faster */ + } + else + { + GotoPos(0, ys); + for(i = n; i-- > 0; ) + AddCStr(D_SR); + } + } + else if (alok && dlok) + { + if (up || ye != D_bot) + { + GotoPos(0, up ? ys : ye+1-n); + if (D_CDL && !(n == 1 && D_DL)) + AddCStr2(D_CDL, n); + else + for(i = n; i--; ) + AddCStr(D_DL); + } + if (!up || ye != D_bot) + { + GotoPos(0, up ? ye+1-n : ys); + if (D_CAL && !(n == 1 && D_AL)) + AddCStr2(D_CAL, n); + else + for(i = n; i--; ) + AddCStr(D_AL); + } + } + else + { + RefreshArea(xs, ys, xe, ye, 0); + return; + } + if (bce && !D_BE) + { + if (up) + ClearArea(xs, ye - n + 1, xs, xe, xe, ye, bce, 0); + else + ClearArea(xs, ys, xs, xe, xe, ys + n - 1, bce, 0); + } + if (D_lp_missing && missy != D_bot) + WriteLP(D_width - 1, missy); +/* XXX + ChangeScrollRegion(oldtop, oldbot); + if (D_lp_missing && missy != D_bot) + WriteLP(D_width - 1, missy); +*/ +} + +void +SetAttr(new) +register int new; +{ + register int i, j, old, typ; + + if (!display || (old = D_rend.attr) == new) + return; +#ifdef COLORS16 + D_col16change = (old ^ new) & (A_BFG | A_BBG); + new ^= D_col16change; + if (old == new) + return; +#endif +#if defined(TERMINFO) && defined(USE_SGR) + if (D_SA) + { + char *tparm(); + SetFont(ASCII); + ospeed = D_dospeed; + tputs(tparm(D_SA, new & A_SO, new & A_US, new & A_RV, new & A_BL, + new & A_DI, new & A_BD, 0 , 0 , + 0), 1, DoAddChar); + D_rend.attr = new; + D_atyp = 0; +# ifdef COLOR + if (D_hascolor) + rend_setdefault(&D_rend); +# endif + return; + } +#endif + D_rend.attr = new; + typ = D_atyp; + if ((new & old) != old) + { + if ((typ & ATYP_U)) + AddCStr(D_UE); + if ((typ & ATYP_S)) + AddCStr(D_SE); + if ((typ & ATYP_M)) + { + AddCStr(D_ME); +#ifdef COLOR + /* ansi attrib handling: \E[m resets color, too */ + if (D_hascolor) + rend_setdefault(&D_rend); +#endif +#ifdef FONT + if (!D_CG0) + { + /* D_ME may also reset the alternate charset */ + D_rend.font = 0; +# ifdef ENCODINGS + D_realfont = 0; +# endif + } +#endif + } + old = 0; + typ = 0; + } + old ^= new; + for (i = 0, j = 1; old && i < NATTR; i++, j <<= 1) + { + if ((old & j) == 0) + continue; + old ^= j; + if (D_attrtab[i]) + { + AddCStr(D_attrtab[i]); + typ |= D_attrtyp[i]; + } + } + D_atyp = typ; +} + +#ifdef FONT +void +SetFont(new) +int new; +{ + int old = D_rend.font; + if (!display || old == new) + return; + D_rend.font = new; +#ifdef ENCODINGS + if (D_encoding && CanEncodeFont(D_encoding, new)) + return; + if (new == D_realfont) + return; + D_realfont = new; +#endif + if (D_xtable && D_xtable[(int)(unsigned char)new] && + D_xtable[(int)(unsigned char)new][256]) + { + AddCStr(D_xtable[(int)(unsigned char)new][256]); + return; + } + + if (!D_CG0 && new != '0') + { + new = ASCII; + if (old == new) + return; + } + + if (new == ASCII) + AddCStr(D_CE0); +#ifdef DW_CHARS + else if (new < ' ') + { + AddStr("\033$"); + if (new > 2) + AddChar('('); + AddChar(new + '@'); + } +#endif + else + AddCStr2(D_CS0, new); +} +#endif + +#ifdef COLOR + +int +color256to16(jj) +int jj; +{ + int min, max; + int r, g, b; + + if (jj >= 232) + { + jj = (jj - 232) / 6; + jj = (jj & 1) << 3 | (jj & 2 ? 7 : 0); + } + else if (jj >= 16) + { + jj -= 16; + r = jj / 36; + g = (jj / 6) % 6; + b = jj % 6; + min = r < g ? (r < b ? r : b) : (g < b ? g : b); + max = r > g ? (r > b ? r : b) : (g > b ? g : b); + if (min == max) + jj = ((max + 1) & 2) << 2 | ((max + 1) & 4 ? 7 : 0); + else + jj = (b - min) / (max - min) << 2 | (g - min) / (max - min) << 1 | (r - +min) / (max - min) | (max > 3 ? 8 : 0); + } + return jj; +} + +#ifdef COLORS256 +int +color256to88(jj) +int jj; +{ + int r, g, b; + + if (jj >= 232) + return (jj - 232) / 3 + 80; + if (jj >= 16) + { + jj -= 16; + r = jj / 36; + g = (jj / 6) % 6; + b = jj % 6; + return ((r + 1) / 2) * 16 + ((g + 1) / 2) * 4 + ((b + 1) / 2) + 16; + } + return jj; +} +#endif + +void +SetColor(f, b) +int f, b; +{ + int of, ob; + static unsigned char sftrans[8] = {0,4,2,6,1,5,3,7}; + + if (!display) + return; + + of = rend_getfg(&D_rend); + ob = rend_getbg(&D_rend); + +#ifdef COLORS16 + /* intense default not invented yet */ + if (f == 0x100) + f = 0; + if (b == 0x100) + b = 0; +#endif + debug2("SetColor %d %d", coli2e(of), coli2e(ob)); + debug2(" -> %d %d\n", coli2e(f), coli2e(b)); + debug2("(%d %d", of, ob); + debug2(" -> %d %d)\n", f, b); + + if (!D_CAX && D_hascolor && ((f == 0 && f != of) || (b == 0 && b != ob))) + { + if (D_OP) + AddCStr(D_OP); + else + { + int oattr; + oattr = D_rend.attr; + AddCStr(D_ME ? D_ME : "\033[m"); +#ifdef FONT + if (D_ME && !D_CG0) + { + /* D_ME may also reset the alternate charset */ + D_rend.font = 0; +# ifdef ENCODINGS + D_realfont = 0; +# endif + } +#endif + D_atyp = 0; + D_rend.attr = 0; + SetAttr(oattr); + } + of = ob = 0; + } + rend_setfg(&D_rend, f); + rend_setbg(&D_rend, b); +#ifdef COLORS16 + D_col16change = 0; +#endif + if (!D_hascolor) + return; + f = f ? coli2e(f) : -1; + b = b ? coli2e(b) : -1; + of = of ? coli2e(of) : -1; + ob = ob ? coli2e(ob) : -1; +#ifdef COLORS256 + if (f != of && f > 15 && D_CCO != 256) + f = D_CCO == 88 && D_CAF ? color256to88(f) : color256to16(f); + if (f != of && f > 15 && D_CAF) + { + AddCStr2(D_CAF, f); + of = f; + } + if (b != ob && b > 15 && D_CCO != 256) + b = D_CCO == 88 && D_CAB ? color256to88(b) : color256to16(b); + if (b != ob && b > 15 && D_CAB) + { + AddCStr2(D_CAB, b); + ob = b; + } +#endif + if (f != of && f != (of | 8)) + { + if (f == -1) + AddCStr("\033[39m"); /* works because AX is set */ + else if (D_CAF) + AddCStr2(D_CAF, f & 7); + else if (D_CSF) + AddCStr2(D_CSF, sftrans[f & 7]); + } + if (b != ob && b != (ob | 8)) + { + if (b == -1) + AddCStr("\033[49m"); /* works because AX is set */ + else if (D_CAB) + AddCStr2(D_CAB, b & 7); + else if (D_CSB) + AddCStr2(D_CSB, sftrans[b & 7]); + } +#ifdef COLORS16 + if (f != of && D_CXT && (f & 8) != 0 && f != -1) + { +# ifdef TERMINFO + AddCStr2("\033[9%p1%dm", f & 7); +# else + AddCStr2("\033[9%dm", f & 7); +# endif + } + if (b != ob && D_CXT && (b & 8) != 0 && b != -1) + { +# ifdef TERMINFO + AddCStr2("\033[10%p1%dm", b & 7); +# else + AddCStr2("\033[10%dm", b & 7); +# endif + } +#endif +} + +static void +SetBackColor(new) +int new; +{ + if (!display) + return; + SetColor(rend_getfg(&D_rend), new); +} +#endif /* COLOR */ + +void +SetRendition(mc) +struct mchar *mc; +{ + if (!display) + return; +#ifdef COLOR + if (nattr2color && D_hascolor && (mc->attr & nattr2color) != 0) + { + static struct mchar mmc; + int i; + mmc = *mc; + for (i = 0; i < 8; i++) + if (attr2color[i] && (mc->attr & (1 << i)) != 0) + { + if (mc->color == 0 && attr2color[i][3]) + ApplyAttrColor(attr2color[i][3], &mmc); + else if ((mc->color & 0x0f) == 0 && attr2color[i][2]) + ApplyAttrColor(attr2color[i][2], &mmc); + else if ((mc->color & 0xf0) == 0 && attr2color[i][1]) + ApplyAttrColor(attr2color[i][1], &mmc); + else + ApplyAttrColor(attr2color[i][0], &mmc); + } + mc = &mmc; + debug2("SetRendition: mapped to %02x %02x\n", (unsigned char)mc->attr, 0x99 - (unsigned char)mc->color); + } +# ifdef COLORS16 + if (D_hascolor && D_CC8 && (mc->attr & (A_BFG|A_BBG))) + { + int a = mc->attr; + if ((mc->attr & A_BFG) && D_MD) + a |= A_BD; + if ((mc->attr & A_BBG) && D_MB) + a |= A_BL; + if (D_rend.attr != a) + SetAttr(a); + } + else +# endif /* COLORS16 */ +#endif /* COLOR */ + if (D_rend.attr != mc->attr) + SetAttr(mc->attr); + +#ifdef COLOR + if (D_rend.color != mc->color +# ifdef COLORS256 + || D_rend.colorx != mc->colorx +# endif +# ifdef COLORS16 + || D_col16change +# endif + ) + SetColor(rend_getfg(mc), rend_getbg(mc)); +#endif +#ifdef FONT + if (D_rend.font != mc->font) + SetFont(mc->font); +#ifdef UTF8 + if (D_encoding == UTF8) + D_rend.fontx = mc->fontx; +#endif +#endif +} + +void +SetRenditionMline(ml, x) +struct mline *ml; +int x; +{ + if (!display) + return; +#ifdef COLOR + if (nattr2color && D_hascolor && (ml->attr[x] & nattr2color) != 0) + { + struct mchar mc; + copy_mline2mchar(&mc, ml, x); + SetRendition(&mc); + return; + } +# ifdef COLORS16 + if (D_hascolor && D_CC8 && (ml->attr[x] & (A_BFG|A_BBG))) + { + int a = ml->attr[x]; + if ((ml->attr[x] & A_BFG) && D_MD) + a |= A_BD; + if ((ml->attr[x] & A_BBG) && D_MB) + a |= A_BL; + if (D_rend.attr != a) + SetAttr(a); + } + else +# endif /* COLORS16 */ +#endif /* COLOR */ + if (D_rend.attr != ml->attr[x]) + SetAttr(ml->attr[x]); +#ifdef COLOR + if (D_rend.color != ml->color[x] +# ifdef COLORS256 + || D_rend.colorx != ml->colorx[x] +# endif +# ifdef COLORS16 + || D_col16change +# endif + ) + { + struct mchar mc; + copy_mline2mchar(&mc, ml, x); + SetColor(rend_getfg(&mc), rend_getbg(&mc)); + } +#endif +#ifdef FONT + if (D_rend.font != ml->font[x]) + SetFont(ml->font[x]); +#ifdef UTF8 + if (D_encoding == UTF8) + D_rend.fontx = ml->fontx[x]; +#endif +#endif +} + +void +MakeStatus(msg) +char *msg; +{ + register char *s, *t; + register int max; + + if (!display) + return; + + if (D_blocked) + return; + if (!D_tcinited) + { + debug("tc not inited, just writing msg\n"); + if (D_processinputdata) + return; /* XXX: better */ + AddStr(msg); + AddStr("\r\n"); + Flush(0); + return; + } + if (!use_hardstatus || !D_HS) + { + max = D_width; + if (D_CLP == 0) + max--; + } + else + max = D_WS > 0 ? D_WS : (D_width - !D_CLP); + if (D_status) + { + /* same message? */ + if (strcmp(msg, D_status_lastmsg) == 0) + { + debug("same message - increase timeout"); + if (!D_status_obufpos) + SetTimeout(&D_statusev, MsgWait); + return; + } + RemoveStatusMinWait(); + } + for (s = t = msg; *s && t - msg < max; ++s) + if (*s == BELL) + AddCStr(D_BL); + else if ((unsigned char)*s >= ' ' && *s != 0177) + *t++ = *s; + *t = '\0'; + if (t == msg) + return; + if (t - msg >= D_status_buflen) + { + char *buf; + if (D_status_lastmsg) + buf = realloc(D_status_lastmsg, t - msg + 1); + else + buf = malloc(t - msg + 1); + if (buf) + { + D_status_lastmsg = buf; + D_status_buflen = t - msg + 1; + } + } + if (t - msg < D_status_buflen) + strcpy(D_status_lastmsg, msg); + D_status_len = t - msg; + D_status_lastx = D_x; + D_status_lasty = D_y; + if (!use_hardstatus || D_has_hstatus == HSTATUS_IGNORE || D_has_hstatus == HSTATUS_MESSAGE) + { + D_status = STATUS_ON_WIN; + debug1("using STATLINE %d\n", STATLINE); + GotoPos(0, STATLINE); + SetRendition(&mchar_so); + InsertMode(0); + AddStr(msg); + if (D_status_len < max) + { + /* Wayne Davison: add extra space for readability */ + D_status_len++; + SetRendition(&mchar_null); + AddChar(' '); + if (D_status_len < max) + { + D_status_len++; + AddChar(' '); + AddChar('\b'); + } + AddChar('\b'); + } + D_x = -1; + } + else + { + D_status = STATUS_ON_HS; + ShowHStatus(msg); + } + + D_status_obufpos = D_obufp - D_obuf; + ASSERT(D_status_obufpos > 0); + + if (D_status == STATUS_ON_WIN) + { + struct display *olddisplay = display; + struct layer *oldflayer = flayer; + + /* this is copied over from RemoveStatus() */ + D_status = 0; + GotoPos(0, STATLINE); + RefreshLine(STATLINE, 0, D_status_len - 1, 0); + GotoPos(D_status_lastx, D_status_lasty); + flayer = D_forecv ? D_forecv->c_layer : 0; + if (flayer) + LaySetCursor(); + display = olddisplay; + flayer = oldflayer; + D_status = STATUS_ON_WIN; + } +} + +void +RemoveStatus() +{ + struct display *olddisplay; + struct layer *oldflayer; + int where; + + if (!display) + return; + if (!(where = D_status)) + return; + + debug("RemoveStatus\n"); + if (D_status_obuffree >= 0) + { + D_obuflen = D_status_obuflen; + D_obuffree = D_status_obuffree; + D_status_obuffree = -1; + } + D_status = 0; + D_status_obufpos = 0; + D_status_bell = 0; + evdeq(&D_statusev); + olddisplay = display; + oldflayer = flayer; + if (where == STATUS_ON_WIN) + { + if (captionalways || (D_canvas.c_slperp && D_canvas.c_slperp->c_slnext)) + { + GotoPos(0, STATLINE); + RefreshLine(STATLINE, 0, D_status_len - 1, 0); + GotoPos(D_status_lastx, D_status_lasty); + } + } + else + RefreshHStatus(); + flayer = D_forecv ? D_forecv->c_layer : 0; + if (flayer) + LaySetCursor(); + display = olddisplay; + flayer = oldflayer; +} + +/* Remove the status but make sure that it is seen for MsgMinWait ms */ +static void +RemoveStatusMinWait() +{ + /* XXX: should flush output first if D_status_obufpos is set */ + if (!D_status_bell && !D_status_obufpos) + { + struct timeval now; + int ti; + gettimeofday(&now, NULL); + ti = (now.tv_sec - D_status_time.tv_sec) * 1000 + (now.tv_usec - D_status_time.tv_usec) / 1000; + if (ti < MsgMinWait) + DisplaySleep1000(MsgMinWait - ti, 0); + } + RemoveStatus(); +} + +#ifdef UTF8 +static int +strlen_onscreen(unsigned char *c, unsigned char *end) +{ + int len = 0; + while (*c && (!end || c < end)) + { + int v, dec = 0; + do + { + v = FromUtf8(*c++, &dec); + if (v == -2) + c--; + } + while (v < 0 && (!end || c < end)); + if (!utf8_iscomb(v)) + { + if (utf8_isdouble(v)) + len++; + len++; + } + } + + return len; +} + +static int +PrePutWinMsg(s, start, max) +char *s; +int start, max; +{ + /* Avoid double-encoding problem for a UTF-8 message on a UTF-8 locale. + Ideally, this would not be necessary. But fixing it the Right Way will + probably take way more time. So this will have to do for now. */ + if (D_encoding == UTF8) + { + int chars = strlen_onscreen((unsigned char *)(s + start), (unsigned char *)(s + max)); + D_encoding = 0; + PutWinMsg(s, start, max + ((max - start) - chars)); /* Multibyte count */ + D_encoding = UTF8; + D_x -= (max - chars); /* Yak! But this is necessary to count for + the fact that not every byte represents a + character. */ + return start + chars; + } + else + { + PutWinMsg(s, start, max); + return max; + } +} +#else +static int +PrePutWinMsg(s, start, max) +char *s; +int start, max; +{ + PutWinMsg(s, start, max); + return max; +} +#endif + +/* refresh the display's hstatus line */ +void +ShowHStatus(str) +char *str; +{ + int l, ox, oy, max; + + if (D_status == STATUS_ON_WIN && D_has_hstatus == HSTATUS_LASTLINE && STATLINE == D_height-1) + return; /* sorry, in use */ + if (D_blocked) + return; + + if (D_HS && D_has_hstatus == HSTATUS_HS) + { + if (!D_hstatus && (str == 0 || *str == 0)) + return; + debug("ShowHStatus: using HS\n"); + SetRendition(&mchar_null); + InsertMode(0); + if (D_hstatus) + AddCStr(D_DS); + D_hstatus = 0; + if (str == 0 || *str == 0) + return; + AddCStr2(D_TS, 0); + max = D_WS > 0 ? D_WS : (D_width - !D_CLP); + if ((int)strlen(str) > max) + AddStrn(str, max); + else + AddStr(str); + AddCStr(D_FS); + D_hstatus = 1; + } + else if (D_has_hstatus == HSTATUS_LASTLINE) + { + debug("ShowHStatus: using last line\n"); + ox = D_x; + oy = D_y; + str = str ? str : ""; + l = strlen(str); + if (l > D_width) + l = D_width; + GotoPos(0, D_height - 1); + SetRendition(captionalways || D_cvlist == 0 || D_cvlist->c_next ? &mchar_null: &mchar_so); + l = PrePutWinMsg(str, 0, l); + if (!captionalways && D_cvlist && !D_cvlist->c_next) + while (l++ < D_width) + PUTCHARLP(' '); + if (l < D_width) + ClearArea(l, D_height - 1, l, D_width - 1, D_width - 1, D_height - 1, 0, 0); + if (ox != -1 && oy != -1) + GotoPos(ox, oy); + D_hstatus = *str ? 1 : 0; + SetRendition(&mchar_null); + } + else if (D_has_hstatus == HSTATUS_FIRSTLINE) + { + debug("ShowHStatus: using first line\n"); + ox = D_x; + oy = D_y; + str = str ? str : ""; + l = strlen(str); + if (l > D_width) + l = D_width; + GotoPos(0, 0); + SetRendition(captionalways || D_cvlist == 0 || D_cvlist->c_next ? &mchar_null: &mchar_so); + l = PrePutWinMsg(str, 0, l); + if (!captionalways || (D_cvlist && !D_cvlist->c_next)) + while (l++ < D_width) + PUTCHARLP(' '); + if (l < D_width) + ClearArea(l, 0, l, D_width - 1, D_width - 1, 0, 0, 0); + if (ox != -1 && oy != -1) + GotoPos(ox, oy); + D_hstatus = *str ? 1 : 0; + SetRendition(&mchar_null); + } + else if (str && *str && D_has_hstatus == HSTATUS_MESSAGE) + { + debug("ShowHStatus: using message\n"); + Msg(0, "%s", str); + } +} + + +/* + * Refreshes the harstatus of the fore window. Shouldn't be here... + */ +void +RefreshHStatus() +{ + char *buf; +#ifdef UTF8 + int extrabytes = strlen(hstatusstring) - strlen_onscreen((unsigned char *)hstatusstring, NULL); +#else + int extrabytes = 0; +#endif + evdeq(&D_hstatusev); + if (D_status == STATUS_ON_HS) + return; + buf = MakeWinMsgEv(hstatusstring, D_fore, '%', (D_HS && D_has_hstatus == HSTATUS_HS && D_WS > 0) ? D_WS : D_width - !D_CLP + extrabytes, &D_hstatusev, 0); + if (buf && *buf) + { + ShowHStatus(buf); + if (D_has_hstatus != HSTATUS_IGNORE && D_hstatusev.timeout.tv_sec) + evenq(&D_hstatusev); + } + else + ShowHStatus((char *)0); +} + +/*********************************************************************/ +/* + * Here come the routines that refresh an arbitrary part of the screen. + */ + +void +RefreshAll(isblank) +int isblank; +{ + struct canvas *cv; + + ASSERT(display); + debug("Signalling full refresh!\n"); + for (cv = D_cvlist; cv; cv = cv->c_next) + { + CV_CALL(cv, LayRedisplayLine(-1, -1, -1, isblank)); + display = cv->c_display; /* just in case! */ + } + RefreshArea(0, 0, D_width - 1, D_height - 1, isblank); +} + +void +RefreshArea(xs, ys, xe, ye, isblank) +int xs, ys, xe, ye, isblank; +{ + int y; + ASSERT(display); + debug2("Refresh Area: %d,%d", xs, ys); + debug3(" - %d,%d (isblank=%d)\n", xe, ye, isblank); + if (!isblank && xs == 0 && xe == D_width - 1 && ye == D_height - 1 && (ys == 0 || D_CD)) + { + ClearArea(xs, ys, xs, xe, xe, ye, 0, 0); + isblank = 1; + } + for (y = ys; y <= ye; y++) + RefreshLine(y, xs, xe, isblank); +} + +void +RefreshLine(y, from, to, isblank) +int y, from, to, isblank; +{ + struct viewport *vp, *lvp; + struct canvas *cv, *lcv, *cvlist, *cvlnext; + struct layer *oldflayer; + int xx, yy, l; + char *buf; + struct win *p; + + ASSERT(display); + + debug2("RefreshLine %d %d", y, from); + debug2(" %d %d\n", to, isblank); + + if (D_status == STATUS_ON_WIN && y == STATLINE) + { + if (to >= D_status_len) + D_status_len = to + 1; + return; /* can't refresh status */ + } + + if (isblank == 0 && D_CE && to == D_width - 1 && from < to && D_status != STATUS_ON_HS) + { + GotoPos(from, y); + if (D_UT || D_BE) + SetRendition(&mchar_null); + AddCStr(D_CE); + isblank = 1; + } + + if ((y == D_height - 1 && D_has_hstatus == HSTATUS_LASTLINE) || (y == 0 && D_has_hstatus == HSTATUS_FIRSTLINE) ) + { + RefreshHStatus(); + return; + } + + while (from <= to) + { + lcv = 0; + lvp = 0; + for (cv = display->d_cvlist; cv; cv = cv->c_next) + { + if (y == cv->c_ye + 1 && from >= cv->c_xs && from <= cv->c_xe) + { +#ifdef UTF8 + int extrabytes = strlen(captionstring) - strlen_onscreen((unsigned char *)captionstring, NULL); +#else + int extrabytes = 0; +#endif + p = Layer2Window(cv->c_layer); + buf = MakeWinMsgEv(captionstring, p, '%', cv->c_xe - cv->c_xs + (cv->c_xe + 1 < D_width || D_CLP) + extrabytes, &cv->c_captev, 0); + if (cv->c_captev.timeout.tv_sec) + evenq(&cv->c_captev); + xx = to > cv->c_xe ? cv->c_xe : to; + l = strlen(buf); + GotoPos(from, y); + SetRendition(&mchar_so); + if (l > xx - cv->c_xs + 1) + l = xx - cv->c_xs + 1; + l = PrePutWinMsg(buf, from - cv->c_xs, l + extrabytes); + from = cv->c_xs + l; + for (; from <= xx; from++) + PUTCHARLP(' '); + break; + } + if (from == cv->c_xe + 1 && y >= cv->c_ys && y <= cv->c_ye + 1) + { + GotoPos(from, y); + SetRendition(&mchar_so); + PUTCHARLP(' '); + from++; + break; + } + if (y < cv->c_ys || y > cv->c_ye || to < cv->c_xs || from > cv->c_xe) + continue; + debug2("- canvas hit: %d %d", cv->c_xs, cv->c_ys); + debug2(" %d %d\n", cv->c_xe, cv->c_ye); + for (vp = cv->c_vplist; vp; vp = vp->v_next) + { + debug2(" - vp: %d %d", vp->v_xs, vp->v_ys); + debug2(" %d %d\n", vp->v_xe, vp->v_ye); + /* find leftmost overlapping vp */ + if (y >= vp->v_ys && y <= vp->v_ye && from <= vp->v_xe && to >= vp->v_xs && (lvp == 0 || lvp->v_xs > vp->v_xs)) + { + lcv = cv; + lvp = vp; + } + } + } + if (cv) + continue; /* we advanced from */ + if (lvp == 0) + break; + if (from < lvp->v_xs) + { + if (!isblank) + DisplayLine(&mline_null, &mline_blank, y, from, lvp->v_xs - 1); + from = lvp->v_xs; + } + + /* call LayRedisplayLine on canvas lcv viewport lvp */ + yy = y - lvp->v_yoff; + xx = to < lvp->v_xe ? to : lvp->v_xe; + + if (lcv->c_layer && lcv->c_xoff + lcv->c_layer->l_width == from) + { + GotoPos(from, y); + SetRendition(&mchar_blank); + PUTCHARLP('|'); + from++; + } + if (lcv->c_layer && yy == lcv->c_layer->l_height) + { + GotoPos(from, y); + SetRendition(&mchar_blank); + while (from <= lvp->v_xe && from - lvp->v_xoff < lcv->c_layer->l_width) + { + PUTCHARLP('-'); + from++; + } + if (from >= lvp->v_xe + 1) + continue; + } + if (lcv->c_layer == 0 || yy >= lcv->c_layer->l_height || from - lvp->v_xoff >= lcv->c_layer->l_width) + { + if (!isblank) + DisplayLine(&mline_null, &mline_blank, y, from, lvp->v_xe); + from = lvp->v_xe + 1; + continue; + } + + if (xx - lvp->v_xoff >= lcv->c_layer->l_width) + xx = lcv->c_layer->l_width + lvp->v_xoff - 1; + oldflayer = flayer; + flayer = lcv->c_layer; + cvlist = flayer->l_cvlist; + cvlnext = lcv->c_lnext; + flayer->l_cvlist = lcv; + lcv->c_lnext = 0; + LayRedisplayLine(yy, from - lvp->v_xoff, xx - lvp->v_xoff, isblank); + flayer->l_cvlist = cvlist; + lcv->c_lnext = cvlnext; + flayer = oldflayer; + + from = xx + 1; + } + if (!isblank && from <= to) + DisplayLine(&mline_null, &mline_blank, y, from, to); +} + +/*********************************************************************/ + +/* clear lp_missing by writing the char on the screen. The + * position must be safe. + */ +static void +WriteLP(x2, y2) +int x2, y2; +{ + struct mchar oldrend; + + ASSERT(display); + ASSERT(D_lp_missing); + oldrend = D_rend; + debug2("WriteLP(%d,%d)\n", x2, y2); +#ifdef DW_CHARS + if (D_lpchar.mbcs) + { + if (x2 > 0) + x2--; + else + D_lpchar = mchar_blank; + } +#endif + /* Can't use PutChar */ + GotoPos(x2, y2); + SetRendition(&D_lpchar); + PUTCHAR(D_lpchar.image); +#ifdef DW_CHARS + if (D_lpchar.mbcs) + PUTCHAR(D_lpchar.mbcs); +#endif + D_lp_missing = 0; + SetRendition(&oldrend); +} + +void +ClearLine(oml, y, from, to, bce) +struct mline *oml; +int from, to, y, bce; +{ + int x; +#ifdef COLOR + struct mchar bcechar; +#endif + + debug3("ClearLine %d,%d-%d\n", y, from, to); + if (D_UT) /* Safe to erase ? */ + SetRendition(&mchar_null); +#ifdef COLOR + if (D_BE) + SetBackColor(bce); +#endif + if (from == 0 && D_CB && (to != D_width - 1 || (D_x == to && D_y == y)) && (!bce || D_BE)) + { + GotoPos(to, y); + AddCStr(D_CB); + return; + } + if (to == D_width - 1 && D_CE && (!bce || D_BE)) + { + GotoPos(from, y); + AddCStr(D_CE); + return; + } + if (oml == 0) + oml = &mline_null; +#ifdef COLOR + if (!bce) + { + DisplayLine(oml, &mline_blank, y, from, to); + return; + } + bcechar = mchar_null; + rend_setbg(&bcechar, bce); + for (x = from; x <= to; x++) + copy_mchar2mline(&bcechar, &mline_old, x); + DisplayLine(oml, &mline_old, y, from, to); +#else + DisplayLine(oml, &mline_blank, y, from, to); +#endif +} + +void +DisplayLine(oml, ml, y, from, to) +struct mline *oml, *ml; +int from, to, y; +{ + register int x; + int last2flag = 0, delete_lp = 0; + + ASSERT(display); + ASSERT(y >= 0 && y < D_height); + ASSERT(from >= 0 && from < D_width); + ASSERT(to >= 0 && to < D_width); + if (!D_CLP && y == D_bot && to == D_width - 1) + { + if (D_lp_missing || !cmp_mline(oml, ml, to)) + { +#ifdef DW_CHARS + if ((D_IC || D_IM) && from < to && !dw_left(ml, to, D_encoding)) +#else + if ((D_IC || D_IM) && from < to) +#endif + { + last2flag = 1; + D_lp_missing = 0; + to--; + } + else + { + delete_lp = !cmp_mchar_mline(&mchar_blank, oml, to) && (D_CE || D_DC || D_CDC); + D_lp_missing = !cmp_mchar_mline(&mchar_blank, ml, to); + copy_mline2mchar(&D_lpchar, ml, to); + } + } + to--; + } +#ifdef DW_CHARS + if (D_mbcs) + { + /* finish dw-char (can happen after a wrap) */ + debug("DisplayLine finishing kanji\n"); + SetRenditionMline(ml, from); + PUTCHAR(ml->image[from]); + from++; + } +#endif + for (x = from; x <= to; x++) + { +#if 0 /* no longer needed */ + if (x || D_x != D_width || D_y != y - 1) +#endif + { + if (ml != NULL && (x < to || x != D_width - 1 || ml->image[x + 1])) + if (cmp_mline(oml, ml, x)) + continue; + GotoPos(x, y); + } +#ifdef DW_CHARS + if (dw_right(ml, x, D_encoding)) + { + x--; + debug1("DisplayLine on right side of dw char- x now %d\n", x); + GotoPos(x, y); + } + if (x == to && dw_left(ml, x, D_encoding)) + break; /* don't start new kanji */ +#endif + SetRenditionMline(ml, x); + PUTCHAR(ml->image[x]); +#ifdef DW_CHARS + if (dw_left(ml, x, D_encoding)) + PUTCHAR(ml->image[++x]); +#endif + } +#if 0 /* not needed any longer */ + /* compare != 0 because ' ' can happen when clipping occures */ + if (to == D_width - 1 && y < D_height - 1 && D_x == D_width && ml->image[to + 1]) + GotoPos(0, y + 1); +#endif + if (last2flag) + { + GotoPos(x, y); + SetRenditionMline(ml, x + 1); + PUTCHAR(ml->image[x + 1]); + GotoPos(x, y); + SetRenditionMline(ml, x); + INSERTCHAR(ml->image[x]); + } + else if (delete_lp) + { + if (D_UT) + SetRendition(&mchar_null); + if (D_DC) + AddCStr(D_DC); + else if (D_CDC) + AddCStr2(D_CDC, 1); + else if (D_CE) + AddCStr(D_CE); + } +} + +void +PutChar(c, x, y) +struct mchar *c; +int x, y; +{ + GotoPos(x, y); + SetRendition(c); + PUTCHARLP(c->image); +#ifdef DW_CHARS + if (c->mbcs) + { +# ifdef UTF8 + if (D_encoding == UTF8) + D_rend.font = 0; +# endif + PUTCHARLP(c->mbcs); + } +#endif +} + +void +InsChar(c, x, xe, y, oml) +struct mchar *c; +int x, xe, y; +struct mline *oml; +{ + GotoPos(x, y); + if (y == D_bot && !D_CLP) + { + if (x == D_width - 1) + { + D_lp_missing = 1; + D_lpchar = *c; + return; + } + if (xe == D_width - 1) + D_lp_missing = 0; + } + if (x == xe) + { + SetRendition(c); + PUTCHARLP(c->image); + return; + } + if (!(D_IC || D_CIC || D_IM) || xe != D_width - 1) + { + RefreshLine(y, x, xe, 0); + GotoPos(x + 1, y); + /* UpdateLine(oml, y, x, xe); */ + return; + } + InsertMode(1); + if (!D_insert) + { +#ifdef DW_CHARS + if (c->mbcs && D_IC) + AddCStr(D_IC); + if (D_IC) + AddCStr(D_IC); + else + AddCStr2(D_CIC, c->mbcs ? 2 : 1); +#else + if (D_IC) + AddCStr(D_IC); + else + AddCStr2(D_CIC, 1); +#endif + } + SetRendition(c); + RAW_PUTCHAR(c->image); +#ifdef DW_CHARS + if (c->mbcs) + { +# ifdef UTF8 + if (D_encoding == UTF8) + D_rend.font = 0; +# endif + if (D_x == D_width - 1) + PUTCHARLP(c->mbcs); + else + RAW_PUTCHAR(c->mbcs); + } +#endif +} + +void +WrapChar(c, x, y, xs, ys, xe, ye, ins) +struct mchar *c; +int x, y; +int xs, ys, xe, ye; +int ins; +{ + int bce; + +#ifdef COLOR + bce = rend_getbg(c); +#else + bce = 0; +#endif + debug("WrapChar:"); + debug2(" x %d y %d", x, y); + debug2(" Dx %d Dy %d", D_x, D_y); + debug2(" xs %d ys %d", xs, ys); + debug3(" xe %d ye %d ins %d\n", xe, ye, ins); + if (xs != 0 || x != D_width || !D_AM) + { + if (y == ye) + ScrollV(xs, ys, xe, ye, 1, bce); + else if (y < D_height - 1) + y++; + if (ins) + InsChar(c, xs, xe, y, 0); + else + PutChar(c, xs, y); + return; + } + if (y == ye) /* we have to scroll */ + { + debug("- scrolling\n"); + ChangeScrollRegion(ys, ye); + if (D_bot != y || D_x != D_width || (!bce && !D_BE)) + { + debug("- have to call ScrollV\n"); + ScrollV(xs, ys, xe, ye, 1, bce); + y--; + } + } + else if (y == D_bot) /* remove unusable region? */ + ChangeScrollRegion(0, D_height - 1); + if (D_x != D_width || D_y != y) + { + if (D_CLP && y >= 0) /* don't even try if !LP */ + RefreshLine(y, D_width - 1, D_width - 1, 0); + debug2("- refresh last char -> x,y now %d,%d\n", D_x, D_y); + if (D_x != D_width || D_y != y) /* sorry, no bonus */ + { + if (y == ye) + ScrollV(xs, ys, xe, ye, 1, bce); + GotoPos(xs, y == ye || y == D_height - 1 ? y : y + 1); + } + } + debug("- writeing new char"); + if (y != ye && y < D_height - 1) + y++; + if (ins != D_insert) + InsertMode(ins); + if (ins && !D_insert) + { + InsChar(c, 0, xe, y, 0); + debug2(" -> done with insert (%d,%d)\n", D_x, D_y); + return; + } + D_y = y; + D_x = 0; + SetRendition(c); + RAW_PUTCHAR(c->image); +#ifdef DW_CHARS + if (c->mbcs) + { +# ifdef UTF8 + if (D_encoding == UTF8) + D_rend.font = 0; +# endif + RAW_PUTCHAR(c->mbcs); + } +#endif + debug2(" -> done (%d,%d)\n", D_x, D_y); +} + +int +ResizeDisplay(wi, he) +int wi, he; +{ + ASSERT(display); + debug2("ResizeDisplay: to (%d,%d).\n", wi, he); + if (D_width == wi && D_height == he) + { + debug("ResizeDisplay: No change\n"); + return 0; + } + if (D_width != wi && (D_height == he || !D_CWS) && D_CZ0 && (wi == Z0width || wi == Z1width)) + { + debug("ResizeDisplay: using Z0/Z1\n"); + AddCStr(wi == Z0width ? D_CZ0 : D_CZ1); + ChangeScreenSize(wi, D_height, 0); + return (he == D_height) ? 0 : -1; + } + if (D_CWS) + { + debug("ResizeDisplay: using WS\n"); + AddCStr(tgoto(D_CWS, wi, he)); + ChangeScreenSize(wi, he, 0); + return 0; + } + return -1; +} + +void +ChangeScrollRegion(newtop, newbot) +int newtop, newbot; +{ + if (display == 0) + return; + if (newtop == newbot) + return; /* xterm etc can't do it */ + if (newtop == -1) + newtop = 0; + if (newbot == -1) + newbot = D_height - 1; + if (D_CS == 0) + { + D_top = 0; + D_bot = D_height - 1; + return; + } + if (D_top == newtop && D_bot == newbot) + return; + debug2("ChangeScrollRegion: (%d - %d)\n", newtop, newbot); + AddCStr(tgoto(D_CS, newbot, newtop)); + D_top = newtop; + D_bot = newbot; + D_y = D_x = -1; /* Just in case... */ +} + +#ifdef RXVT_OSC +#define WT_FLAG "2" /* change to "0" to set both title and icon */ + +void +SetXtermOSC(i, s, t) +int i; +char *s; +char *t; +{ + static char *oscs[][2] = { + { WT_FLAG ";", "screen" }, /* set window title */ + { "11;", ""}, /* background RGB */ + { "20;", "" }, /* background */ + { "39;", "black" }, /* default foreground (black?) */ + { "49;", "white" } /* default background (white?) */ + }; + + ASSERT(display); + if (!D_CXT) + return; + if (!s) + s = ""; + if (!D_xtermosc[i] && !*s) + return; + if (i == 0 && !D_xtermosc[0]) + AddStr("\033[22;" WT_FLAG "t"); /* stack titles (xterm patch #251) */ + if (!*s) + s = oscs[i][1]; + D_xtermosc[i] = 1; + AddStr("\033]"); + AddStr(oscs[i][0]); + AddStr(s); + AddStr(t); +} + +void +ClearAllXtermOSC() +{ + int i; + for (i = 4; i >= 0; i--) + SetXtermOSC(i, 0, "\a"); + if (D_xtermosc[0]) + AddStr("\033[23;" WT_FLAG "t"); /* unstack titles (xterm patch #251) */ +} +#undef WT_FLAG +#endif + +/* + * Output buffering routines + */ + +void +AddStr(str) +char *str; +{ + register char c; + + ASSERT(display); + +#ifdef UTF8 + if (D_encoding == UTF8) + { + while ((c = *str++)) + AddUtf8((unsigned char)c); + return; + } +#endif + while ((c = *str++)) + AddChar(c); +} + +void +AddStrn(str, n) +char *str; +int n; +{ + register char c; + + ASSERT(display); +#ifdef UTF8 + if (D_encoding == UTF8) + { + while ((c = *str++) && n-- > 0) + AddUtf8((unsigned char)c); + } + else +#endif + while ((c = *str++) && n-- > 0) + AddChar(c); + while (n-- > 0) + AddChar(' '); +} + +void +Flush(progress) +int progress; +{ + register int l; + int wr; + register char *p; + + ASSERT(display); + l = D_obufp - D_obuf; + debug1("Flush(): %d\n", l); + if (l == 0) + return; + ASSERT(l + D_obuffree == D_obuflen); + if (D_userfd < 0) + { + D_obuffree += l; + D_obufp = D_obuf; + return; + } + p = D_obuf; + if (!progress) + { + if (fcntl(D_userfd, F_SETFL, 0)) + debug1("Warning: BLOCK fcntl failed: %d\n", errno); + } + while (l) + { + if (progress) + { + fd_set w; + FD_ZERO(&w); + FD_SET(D_userfd, &w); + struct timeval t; + t.tv_sec = progress; + t.tv_usec = 0; + wr = select(FD_SETSIZE, (fd_set *)0, &w, (fd_set *)0, &t); + if (wr == -1) + { + if (errno == EINTR) + continue; + debug1("Warning: select failed: %d\n", errno); + break; + } + if (wr == 0) + { + /* no progress after 3 seconds. sorry. */ + debug1("Warning: no progress after %d seconds\n", progress); + break; + } + } + wr = write(D_userfd, p, l); + if (wr <= 0) + { + if (errno == EINTR) + continue; + debug1("Writing to display: %d\n", errno); + break; + } + D_obuffree += wr; + p += wr; + l -= wr; + } + if (l) + debug1("Warning: Flush could not write %d bytes\n", l); + D_obuffree += l; + D_obufp = D_obuf; + if (!progress) + { + if (fcntl(D_userfd, F_SETFL, FNBLOCK)) + debug1("Warning: NBLOCK fcntl failed: %d\n", errno); + } + if (D_blocked == 1) + D_blocked = 0; + D_blocked_fuzz = 0; +} + +void +freetty() +{ + if (D_userfd >= 0) + close(D_userfd); + debug1("did freetty %d\n", D_userfd); + D_userfd = -1; + D_obufp = 0; + D_obuffree = 0; + if (D_obuf) + free(D_obuf); + D_obuf = 0; + D_obuflen = 0; + D_obuflenmax = -D_obufmax; + D_blocked = 0; + D_blocked_fuzz = 0; +} + +/* + * Asynchronous output routines by + * Tim MacKenzie (tym@dibbler.cs.monash.edu.au) + */ + +void +Resize_obuf() +{ + register int ind; + + ASSERT(display); + if (D_status_obuffree >= 0) + { + ASSERT(D_obuffree == -1); + RemoveStatusMinWait(); + if (--D_obuffree > 0) /* redo AddChar decrement */ + return; + } + if (D_obuflen && D_obuf) + { + ind = D_obufp - D_obuf; + D_obuflen += GRAIN; + D_obuffree += GRAIN; + D_obuf = realloc(D_obuf, D_obuflen); + } + else + { + ind = 0; + D_obuflen = GRAIN; + D_obuffree = GRAIN; + D_obuf = malloc(D_obuflen); + } + if (!D_obuf) + Panic(0, "Out of memory"); + D_obufp = D_obuf + ind; + D_obuflenmax = D_obuflen - D_obufmax; + debug1("ResizeObuf: resized to %d\n", D_obuflen); +} + +void +DisplaySleep1000(n, eat) +int n; +int eat; +{ + char buf; + fd_set r; + struct timeval t; + + if (n <= 0) + return; + if (!display) + { + debug("DisplaySleep has no display sigh\n"); + sleep1000(n); + return; + } + t.tv_usec = (n % 1000) * 1000; + t.tv_sec = n / 1000; + FD_ZERO(&r); + FD_SET(D_userfd, &r); + if (select(FD_SETSIZE, &r, (fd_set *)0, (fd_set *)0, &t) > 0) + { + debug("display activity stopped sleep\n"); + if (eat) + read(D_userfd, &buf, 1); + } + debug2("DisplaySleep(%d) ending, eat was %d\n", n, eat); +} + +#ifdef AUTO_NUKE +void +NukePending() +{/* Nuke pending output in current display, clear screen */ + register int len; + int oldtop = D_top, oldbot = D_bot; + struct mchar oldrend; + int oldkeypad = D_keypad, oldcursorkeys = D_cursorkeys; + int oldcurvis = D_curvis; + int oldmouse = D_mouse; + int oldextmouse = D_extmouse; + + oldrend = D_rend; + len = D_obufp - D_obuf; + debug1("NukePending: nuking %d chars\n", len); + + /* Throw away any output that we can... */ +# ifdef POSIX + tcflush(D_userfd, TCOFLUSH); +# else +# ifdef TCFLSH + (void) ioctl(D_userfd, TCFLSH, (char *) 1); +# endif +# endif + + D_obufp = D_obuf; + D_obuffree += len; + D_top = D_bot = -1; + AddCStr(D_IS); + AddCStr(D_TI); + /* Turn off all attributes. (Tim MacKenzie) */ + if (D_ME) + AddCStr(D_ME); + else + { +#ifdef COLOR + if (D_hascolor) + AddStr("\033[m"); /* why is D_ME not set? */ +#endif + AddCStr(D_SE); + AddCStr(D_UE); + } + /* Check for toggle */ + if (D_IM && strcmp(D_IM, D_EI)) + AddCStr(D_EI); + D_insert = 0; + /* Check for toggle */ +#ifdef MAPKEYS + if (D_KS && strcmp(D_KS, D_KE)) + AddCStr(D_KS); + if (D_CCS && strcmp(D_CCS, D_CCE)) + AddCStr(D_CCS); +#else + if (D_KS && strcmp(D_KS, D_KE)) + AddCStr(D_KE); + D_keypad = 0; + if (D_CCS && strcmp(D_CCS, D_CCE)) + AddCStr(D_CCE); + D_cursorkeys = 0; +#endif + AddCStr(D_CE0); + D_rend = mchar_null; + D_atyp = 0; + AddCStr(D_DS); + D_hstatus = 0; + AddCStr(D_VE); + D_curvis = 0; + ChangeScrollRegion(oldtop, oldbot); + SetRendition(&oldrend); + KeypadMode(oldkeypad); + CursorkeysMode(oldcursorkeys); + CursorVisibility(oldcurvis); + MouseMode(oldmouse); + ExtMouseMode(oldextmouse); + if (D_CWS) + { + debug("ResizeDisplay: using WS\n"); + AddCStr(tgoto(D_CWS, D_width, D_height)); + } + else if (D_CZ0 && (D_width == Z0width || D_width == Z1width)) + { + debug("ResizeDisplay: using Z0/Z1\n"); + AddCStr(D_width == Z0width ? D_CZ0 : D_CZ1); + } +} +#endif /* AUTO_NUKE */ + +#ifdef linux +/* linux' select can't handle flow control, so wait 100ms if + * we get EAGAIN + */ +static void +disp_writeev_eagain(ev, data) +struct event *ev; +char *data; +{ + display = (struct display *)data; + evdeq(&D_writeev); + D_writeev.type = EV_WRITE; + D_writeev.handler = disp_writeev_fn; + evenq(&D_writeev); +} +#endif + +static void +disp_writeev_fn(ev, data) +struct event *ev; +char *data; +{ + int len, size = OUTPUT_BLOCK_SIZE; + + display = (struct display *)data; + len = D_obufp - D_obuf; + if (len < size) + size = len; + if (D_status_obufpos && size > D_status_obufpos) + size = D_status_obufpos; + ASSERT(len >= 0); + size = write(D_userfd, D_obuf, size); + if (size >= 0) + { + len -= size; + if (len) + { + bcopy(D_obuf + size, D_obuf, len); + debug2("ASYNC: wrote %d - remaining %d\n", size, len); + } + D_obufp -= size; + D_obuffree += size; + if (D_status_obufpos) + { + D_status_obufpos -= size; + if (!D_status_obufpos) + { + debug("finished writing the status message\n"); + /* we're finished displaying the message! */ + if (D_status == STATUS_ON_WIN) + { + /* setup continue trigger */ + D_status_obuflen = D_obuflen; + D_status_obuffree = D_obuffree; + /* setting obbuffree to 0 will make AddChar call + * ResizeObuf */ + D_obuffree = D_obuflen = 0; + } + gettimeofday(&D_status_time, NULL); + SetTimeout(&D_statusev, MsgWait); + evenq(&D_statusev); +#ifdef HAVE_BRAILLE + RefreshBraille(); /* let user see multiple Msg()s */ +#endif + } + } + if (D_blocked_fuzz) + { + D_blocked_fuzz -= size; + if (D_blocked_fuzz < 0) + D_blocked_fuzz = 0; + } + if (D_blockedev.queued) + { + if (D_obufp - D_obuf > D_obufmax / 2) + { + debug2("%s: resetting timeout to %g secs\n", D_usertty, D_nonblock/1000.); + SetTimeout(&D_blockedev, D_nonblock); + } + else + { + debug1("%s: deleting blocked timeout\n", D_usertty); + evdeq(&D_blockedev); + } + } + if (D_blocked == 1 && D_obuf == D_obufp) + { + /* empty again, restart output */ + debug1("%s: buffer empty, unblocking\n", D_usertty); + D_blocked = 0; + Activate(D_fore ? D_fore->w_norefresh : 0); + D_blocked_fuzz = D_obufp - D_obuf; + } + } + else + { +#ifdef linux + /* linux flow control is badly broken */ + if (errno == EAGAIN) + { + evdeq(&D_writeev); + D_writeev.type = EV_TIMEOUT; + D_writeev.handler = disp_writeev_eagain; + SetTimeout(&D_writeev, 100); + evenq(&D_writeev); + } +#endif + if (errno != EINTR && errno != EAGAIN) +#if defined(EWOULDBLOCK) && (EWOULDBLOCK != EAGAIN) + if (errno != EWOULDBLOCK) +#endif + Msg(errno, "Error writing output to display"); + } +} + +/* maximum mouse sequence length is SGR: ESC [ < b ; x ; y M */ +#define MAX_MOUSE_SEQUENCE (3+10+1+10+1+10+1) + +static void +disp_readev_fn(ev, data) +struct event *ev; +char *data; +{ + /* We have to intercept mouse sequences in order to translate them + * properly, and an incoming sequence could be spread over multiple + * I/O reads. When this occurs, we buffer intermediate state in + * D_mouse_params, and then use the reservation at the front of + * bufspace to prepend the completed and translated mouse sequence. + */ + int size; + char bufspace[MAX_MOUSE_SEQUENCE + IOSIZE]; + unsigned char *buf = (unsigned char*)bufspace + MAX_MOUSE_SEQUENCE; + + struct canvas *cv; + + display = (struct display *)data; + + /* Hmmmm... a bit ugly... */ + if (D_forecv) + for (cv = D_forecv->c_layer->l_cvlist; cv; cv = cv->c_lnext) + { + display = cv->c_display; + if (D_status == STATUS_ON_WIN) + RemoveStatus(); + } + + display = (struct display *)data; + if (D_fore == 0) + size = IOSIZE; + else + { +#ifdef PSEUDOS + if (W_UWP(D_fore)) + size = sizeof(D_fore->w_pwin->p_inbuf) - D_fore->w_pwin->p_inlen; + else +#endif + size = sizeof(D_fore->w_inbuf) - D_fore->w_inlen; + } + + if (size > IOSIZE) + size = IOSIZE; + if (size <= 0) + size = 1; /* Always allow one char for command keys */ + + size = read(D_userfd, buf, size); + if (size < 0) + { + if (errno == EINTR || errno == EAGAIN) + return; +#if defined(EWOULDBLOCK) && (EWOULDBLOCK != EAGAIN) + if (errno == EWOULDBLOCK) + return; +#endif + debug1("Read error: %d - hangup!\n", errno); + Hangup(); + sleep(1); + return; + } + else if (size == 0) + { + debug("Found EOF - hangup!\n"); + Hangup(); + sleep(1); + return; + } + if (D_blocked == 4) + { + D_blocked = 0; +#ifdef BLANKER_PRG + KillBlanker(); +#endif + Activate(D_fore ? D_fore->w_norefresh : 0); + ResetIdle(); + return; + } +#ifdef ZMODEM + if (D_blocked > 1) /* 2, 3 */ + { + char *bufp; + struct win *p; + + flayer = 0; + for (p = windows; p ; p = p->w_next) + if (p->w_zdisplay == display) + { + flayer = &p->w_layer; + bufp = (char *)buf; + while (size > 0) + LayProcess(&bufp, &size); + return; + } + debug("zmodem window gone, deblocking display"); + zmodem_abort(0, display); + } +#endif + if (idletimo > 0) + ResetIdle(); + if (D_fore) + D_fore->w_lastdisp = display; + + if (D_mouse && D_forecv) + { + unsigned char *bp = (unsigned char *)buf; + unsigned char *end = bp + size; + unsigned char *mark = NULL; + + /* When mouse mode is enabled, buffer up incoming CSI until we + * know whether it is a mouse sequence. If not a mouse event, + * emit the CSI unchanged; if an invalid mouse event, swallow + * it; otherwise, translate the sequence and emit it. + * + * Supported mouse events take two flavors. + * + * VT200: CSI M Cb Cx Cy + * SGR: CSI < Ps ; Ps ; Ps M|m + * + * UTF-8 and UXRVT modes are explicitly rejected because they + * introduce incompatibilities with other control sequences. + * + * NOTE: applications wishing to use SGR mode will normally + * enable VT200 mode first as a fallback in case the terminal + * does not support SGR mode. Thus, we must expect to receive + * either mode's sequences when mouse mode is enabled. We will + * dutifully translate whatever arrives, without attempting to + * convert between modes on behalf of the application. + */ + switch (D_mouse_parse.state) + { + case CSI_PY: + case CSI_PX: + case CSI_PB: + /* Partial mouse sequence; do not restore suppressed + * characters. We will emit a translated version (if valid) + * or swallow them (otherwise). + */ + break; + + case CSI_BEGIN: + /* Partial CSI; restore suppressed characters in case it + * turns out not to be a mouse sequence after all. + */ + *(--buf) = '['; + ++size; + /* fall through */ + + case CSI_ESC_SEEN: + /* Escape character; restore it in case this turns out not + * to be the start of a mouse sequence after all. + */ + *(--buf) = '\033'; + ++size; + break; + + default: + break; + }; + + while (bp != end) + { + unsigned char c = *(bp++); + + switch (D_mouse_parse.state) + { + case CSI_INACTIVE: + if (c == '\033') + { + /* potential escape sequence */ + mark = bp-1; + D_mouse_parse.state = CSI_ESC_SEEN; + } + break; + + case CSI_ESC_SEEN: + if (c == '[') + { + /* continue buffering an escape sequence */ + D_mouse_parse.state = CSI_BEGIN; + } + else + D_mouse_parse.state = CSI_INACTIVE; + break; + + case CSI_BEGIN: + if (c == 'M') + { + /* VT200 mouse sequence */ + D_mouse_parse.state = CSI_PB; + D_mouse_parse.sgrmode = 0; + } + else if (c == '<') + { + /* SGR mouse sequence */ + D_mouse_parse.state = CSI_PB; + D_mouse_parse.params[D_mouse_parse.state] = 0; + D_mouse_parse.sgrmode = 1; + } + else + D_mouse_parse.state = CSI_INACTIVE; + break; + + case CSI_PB: + case CSI_PX: + case CSI_PY: + if (D_mouse_parse.sgrmode) + { + /* SGR mode: parse decimal numbers */ + if ('0' <= c && c <= '9') + { + D_mouse_parse.params[D_mouse_parse.state] *= 10; + D_mouse_parse.params[D_mouse_parse.state] += c - '0'; + } + else if (D_mouse_parse.state == CSI_PY) + { + if (c == 'M' || c == 'm') + D_mouse_parse.state = CSI_DONE; + else + D_mouse_parse.state = CSI_INVALID; + } + else if (c == ';') + { + D_mouse_parse.state++; + D_mouse_parse.params[D_mouse_parse.state] = 0; + } + else + D_mouse_parse.state = CSI_INVALID; + } + else + { + /* VT200 mode: read raw binary values */ + D_mouse_parse.params[D_mouse_parse.state++] = c; + } + break; + + default: + break; + } + + if (D_mouse_parse.state == CSI_INVALID) + { + /* swallow invalid sequence, but emit whatever came before */ + if (buf < mark) + disp_processinput(display, buf, mark-buf); + + buf = bp; + size = end - bp; + D_mouse_parse.state = CSI_INACTIVE; + } + else if (D_mouse_parse.state == CSI_DONE) + { + /* emit whatever came before this sequence */ + if (buf < mark) + disp_processinput(display, buf, mark-buf); + + buf = bp; + size = end - bp; + + int x = D_mouse_parse.params[CSI_PX]; + int y = D_mouse_parse.params[CSI_PY]; + int bias = D_mouse_parse.sgrmode? 1 : 33; + + x -= bias; + y -= bias; + + if (x >= D_forecv->c_xs && x <= D_forecv->c_xe && y >= D_forecv->c_ys && y <= D_forecv->c_ye) + { + if ((D_fore && D_fore->w_mouse) || (D_mousetrack && D_forecv->c_layer->l_mode == 1)) + { + /* Send clicks only if the window is expecting clicks */ + x -= D_forecv->c_xoff; + y -= D_forecv->c_yoff; + + if (x >= 0 && x < D_forecv->c_layer->l_width && y >= 0 && y < D_forecv->c_layer->l_height) + { + char tmp[MAX_MOUSE_SEQUENCE+1]; + int n; + + x += bias; + y += bias; + + if (D_mouse_parse.sgrmode) + { + n = snprintf( + tmp, MAX_MOUSE_SEQUENCE, "\033[<%d;%d;%d%c", + D_mouse_parse.params[CSI_PB], x, y, c); + } + else + { + n = snprintf( + tmp, MAX_MOUSE_SEQUENCE, "\033[M%c%c%c", + D_mouse_parse.params[CSI_PB], x, y); + } + + if (n > MAX_MOUSE_SEQUENCE) + n = MAX_MOUSE_SEQUENCE; + + /* emit sequence */ + buf -= n; + size += n; + memcpy(buf, tmp, n); + } + } + } + else if (D_mousetrack) + { + /* 'focus' to the clicked region, only on mouse up */ + int focus = 0; + if (D_mouse_parse.sgrmode) + focus = (c == 'm'); + else + focus = (D_mouse_parse.params[CSI_PB] == '#'); + + struct canvas *cv = FindCanvas(x, y); + if (focus && cv) + { + SetForeCanvas(display, cv); + /* XXX: Do we want to reset the input buffer? */ + } + } + + D_mouse_parse.state = CSI_INACTIVE; + } + } + + if (D_mouse_parse.state != CSI_INACTIVE) + { + /* suppress partial sequence at end */ + size = mark? mark - buf : 0; + } + } + + if (size > 0) + disp_processinput(display, buf, size); +} + +static void +disp_processinput(display, buf, size) + struct display* display; + unsigned char* buf; + int size; +{ +#ifdef ENCODINGS + if (D_encoding != (D_forecv ? D_forecv->c_layer->l_encoding : 0)) + { + int i, j, c, enc; + char buf2[IOSIZE * 2 + 10]; + enc = D_forecv ? D_forecv->c_layer->l_encoding : 0; + for (i = j = 0; i < size; i++) + { + c = ((unsigned char *)buf)[i]; + c = DecodeChar(c, D_encoding, &D_decodestate); + if (c == -2) + i--; /* try char again */ + if (c < 0) + continue; + if (pastefont) + { + int font = 0; + j += EncodeChar(buf2 + j, c, enc, &font); + j += EncodeChar(buf2 + j, -1, enc, &font); + } + else + j += EncodeChar(buf2 + j, c, enc, 0); + if (j > (int)sizeof(buf2) - 10) /* just in case... */ + break; + } + (*D_processinput)(buf2, j); + return; + } +#endif + (*D_processinput)((char *)buf, size); +} + +static void +disp_status_fn(ev, data) +struct event *ev; +char *data; +{ + display = (struct display *)data; + debug1("disp_status_fn for display %x\n", (int)display); + if (D_status) + RemoveStatus(); +} + +static void +disp_hstatus_fn(ev, data) +struct event *ev; +char *data; +{ + display = (struct display *)data; + if (D_status == STATUS_ON_HS) + { + SetTimeout(ev, 1); + evenq(ev); + return; + } + RefreshHStatus(); +} + +static void +disp_blocked_fn(ev, data) +struct event *ev; +char *data; +{ + struct win *p; + + display = (struct display *)data; + debug1("blocked timeout %s\n", D_usertty); + if (D_obufp - D_obuf > D_obufmax + D_blocked_fuzz) + { + debug("stopping output to display\n"); + D_blocked = 1; + /* re-enable all windows */ + for (p = windows; p; p = p->w_next) + if (p->w_readev.condneg == &D_obuflenmax) + { + debug1("freeing window #%d\n", p->w_number); + p->w_readev.condpos = p->w_readev.condneg = 0; + } + } +} + +#ifdef MAPKEYS +static void +disp_map_fn(ev, data) +struct event *ev; +char *data; +{ + char *p; + int l, i; + unsigned char *q; + display = (struct display *)data; + debug("Flushing map sequence\n"); + if (!(l = D_seql)) + return; + p = (char *)D_seqp - l; + D_seqp = D_kmaps + 3; + D_seql = 0; + if ((q = D_seqh) != 0) + { + D_seqh = 0; + i = q[0] << 8 | q[1]; + i &= ~KMAP_NOTIMEOUT; + debug1("Mapping former hit #%d - ", i); + debug2("%d(%s) - ", q[2], q + 3); + if (StuffKey(i)) + ProcessInput2((char *)q + 3, q[2]); + if (display == 0) + return; + l -= q[2]; + p += q[2]; + } + else + D_dontmap = 1; + ProcessInput(p, l); +} +#endif + +static void +disp_idle_fn(ev, data) +struct event *ev; +char *data; +{ + struct display *olddisplay; + display = (struct display *)data; + debug("idle timeout\n"); + if (idletimo <= 0 || idleaction.nr == RC_ILLEGAL) + return; + olddisplay = display; + flayer = D_forecv->c_layer; + fore = D_fore; + DoAction(&idleaction, -1); + if (idleaction.nr == RC_BLANKER) + return; + for (display = displays; display; display = display->d_next) + if (olddisplay == display) + break; + if (display) + ResetIdle(); +} + +void +ResetIdle() +{ + if (idletimo > 0) + { + SetTimeout(&D_idleev, idletimo); + if (!D_idleev.queued) + evenq(&D_idleev); + } + else + evdeq(&D_idleev); +} + + +#ifdef BLANKER_PRG + +static void +disp_blanker_fn(ev, data) +struct event *ev; +char *data; +{ + char buf[IOSIZE], *b; + int size; + + display = (struct display *)data; + size = read(D_blankerev.fd, buf, IOSIZE); + if (size <= 0) + { + evdeq(&D_blankerev); + close(D_blankerev.fd); + D_blankerev.fd = -1; + return; + } + for (b = buf; size; size--) + AddChar(*b++); +} + +void +KillBlanker() +{ + int oldtop = D_top, oldbot = D_bot; + struct mchar oldrend; + + if (D_blankerev.fd == -1) + return; + if (D_blocked == 4) + D_blocked = 0; + evdeq(&D_blankerev); + close(D_blankerev.fd); + D_blankerev.fd = -1; + Kill(D_blankerpid, SIGHUP); + D_top = D_bot = -1; + oldrend = D_rend; + if (D_ME) + { + AddCStr(D_ME); + AddCStr(D_ME); + } + else + { +#ifdef COLOR + if (D_hascolor) + AddStr("\033[m\033[m"); /* why is D_ME not set? */ +#endif + AddCStr(D_SE); + AddCStr(D_UE); + } + AddCStr(D_VE); + AddCStr(D_CE0); + D_rend = mchar_null; + D_atyp = 0; + D_curvis = 0; + D_x = D_y = -1; + ChangeScrollRegion(oldtop, oldbot); + SetRendition(&oldrend); + ClearAll(); +} + +void +RunBlanker(cmdv) +char **cmdv; +{ + char *m; + int pid; + int slave = -1; + int ptype = 0; + char termname[MAXTERMLEN + 6]; +#ifndef TIOCSWINSZ + char libuf[20], cobuf[20]; +#endif + char **np; + + strcpy(termname, "TERM="); + strncpy(termname + 5, D_termname, MAXTERMLEN - 6); + termname[sizeof(termname) - 1] = 0; + KillBlanker(); + D_blankerpid = -1; + if ((D_blankerev.fd = OpenDevice(cmdv, 0, &ptype, &m)) == -1) + { + Msg(0, "OpenDevice failed"); + return; + } +#ifdef O_NOCTTY + if (pty_preopen) + { + if ((slave = open(m, O_RDWR|O_NOCTTY)) == -1) + { + Msg(errno, "%s", m); + close(D_blankerev.fd); + D_blankerev.fd = -1; + return; + } + } +#endif + switch (pid = (int)fork()) + { + case -1: + Msg(errno, "fork"); + close(D_blankerev.fd); + D_blankerev.fd = -1; + close(slave); + return; + case 0: + displays = 0; + ServerSocket = -1; +#ifdef SIGPIPE + signal(SIGPIPE, SIG_DFL); +#endif + if (setgid(real_gid) || setuid(real_uid)) + Panic(errno, "setuid/setgid"); + eff_uid = real_uid; + eff_gid = real_gid; + brktty(D_userfd); + freetty(); +#ifdef DEBUG + if (dfp && dfp != stderr) + fclose(dfp); +#endif + if (slave != -1) + { + close(0); + dup(slave); + close(slave); + closeallfiles(D_blankerev.fd); + slave = dup(0); + } + else + closeallfiles(D_blankerev.fd); +#ifdef DEBUG + if (dfp) + { + char buf[256]; + + sprintf(buf, "%s/screen.blanker", DEBUGDIR); + if ((dfp = fopen(buf, "a")) == 0) + dfp = stderr; + else + (void) chmod(buf, 0666); + } + debug1("=== RunBlanker: pid %d\n", (int)getpid()); +#endif + close(0); + close(1); + close(2); + if (open(m, O_RDWR)) + Panic(errno, "Cannot open %s", m); + dup(0); + dup(0); + close(D_blankerev.fd); + if (slave != -1) + close(slave); + InitPTY(0); + fgtty(0); + SetTTY(0, &D_OldMode); + np = NewEnv + 3; + *np++ = NewEnv[0]; + *np++ = termname; +#ifdef TIOCSWINSZ + glwz.ws_col = D_width; + glwz.ws_row = D_height; + (void)ioctl(0, TIOCSWINSZ, (char *)&glwz); +#else + /* Always turn off nonblocking mode */ + (void)fcntl(0, F_SETFL, 0); + sprintf(libuf, "LINES=%d", D_height); + sprintf(cobuf, "COLUMNS=%d", D_width); + *np++ = libuf; + *np++ = cobuf; +#endif + debug1("calling execvpe %s\n", *cmdv); + execvpe(*cmdv, cmdv, NewEnv + 3); + debug1("exec error: %d\n", errno); + Panic(errno, "Cannot exec '%s'", *cmdv); + default: + break; + } + D_blankerpid = pid; + evenq(&D_blankerev); + D_blocked = 4; + ClearAll(); + close(slave); +} + +#endif /* BLANKER_PRG */ + + |