+utf8size(char *s) {
+ uchar c = *s;
+
+ if(~c&B7) {
+ return 1;
+ } else if((c&(B7|B6|B5)) == (B7|B6)) {
+ return 2;
+ } else if((c&(B7|B6|B5|B4)) == (B7|B6|B5)) {
+ return 3;
+ } else {
+ return 4;
+ }
+}
+
+void
+selinit(void) {
+ memset(&sel.tclick1, 0, sizeof(sel.tclick1));
+ memset(&sel.tclick2, 0, sizeof(sel.tclick2));
+ sel.mode = 0;
+ sel.bx = -1;
+ sel.clip = NULL;
+ sel.xtarget = XInternAtom(xw.dpy, "UTF8_STRING", 0);
+ if(sel.xtarget == None)
+ sel.xtarget = XA_STRING;
+}
+
+static int
+x2col(int x) {
+ x -= borderpx;
+ x /= xw.cw;
+
+ return LIMIT(x, 0, term.col-1);
+}
+
+static int
+y2row(int y) {
+ y -= borderpx;
+ y /= xw.ch;
+
+ return LIMIT(y, 0, term.row-1);
+}
+
+static inline bool
+selected(int x, int y) {
+ int bx, ex;
+
+ if(sel.ey == y && sel.by == y) {
+ bx = MIN(sel.bx, sel.ex);
+ ex = MAX(sel.bx, sel.ex);
+ return BETWEEN(x, bx, ex);
+ }
+
+ return ((sel.b.y < y && y < sel.e.y)
+ || (y == sel.e.y && x <= sel.e.x))
+ || (y == sel.b.y && x >= sel.b.x
+ && (x <= sel.e.x || sel.b.y != sel.e.y));
+}
+
+void
+getbuttoninfo(XEvent *e) {
+ sel.alt = IS_SET(MODE_ALTSCREEN);
+
+ sel.ex = x2col(e->xbutton.x);
+ sel.ey = y2row(e->xbutton.y);
+
+ sel.b.x = sel.by < sel.ey ? sel.bx : sel.ex;
+ sel.b.y = MIN(sel.by, sel.ey);
+ sel.e.x = sel.by < sel.ey ? sel.ex : sel.bx;
+ sel.e.y = MAX(sel.by, sel.ey);
+}
+
+void
+mousereport(XEvent *e) {
+ int x = x2col(e->xbutton.x), y = y2row(e->xbutton.y),
+ button = e->xbutton.button, state = e->xbutton.state,
+ len;
+ char buf[40];
+ static int ob, ox, oy;
+
+ /* from urxvt */
+ if(e->xbutton.type == MotionNotify) {
+ if(!IS_SET(MODE_MOUSEMOTION) || (x == ox && y == oy))
+ return;
+ button = ob + 32;
+ ox = x, oy = y;
+ } else if(!IS_SET(MODE_MOUSESGR)
+ && (e->xbutton.type == ButtonRelease
+ || button == AnyButton)) {
+ button = 3;
+ } else {
+ button -= Button1;
+ if(button >= 3)
+ button += 64 - 3;
+ if(e->xbutton.type == ButtonPress) {
+ ob = button;
+ ox = x, oy = y;
+ }
+ }
+
+ button += (state & ShiftMask ? 4 : 0)
+ + (state & Mod4Mask ? 8 : 0)
+ + (state & ControlMask ? 16 : 0);
+
+ len = 0;
+ if(IS_SET(MODE_MOUSESGR)) {
+ len = snprintf(buf, sizeof(buf), "\033[<%d;%d;%d%c",
+ button, x+1, y+1,
+ e->xbutton.type == ButtonRelease ? 'm' : 'M');
+ } else if(x < 223 && y < 223) {
+ len = snprintf(buf, sizeof(buf), "\033[M%c%c%c",
+ 32+button, 32+x+1, 32+y+1);
+ } else {
+ return;
+ }
+
+ ttywrite(buf, len);
+}
+
+void
+bpress(XEvent *e) {
+ if(IS_SET(MODE_MOUSE)) {
+ mousereport(e);
+ } else if(e->xbutton.button == Button1) {
+ if(sel.bx != -1) {
+ sel.bx = -1;
+ tsetdirt(sel.b.y, sel.e.y);
+ draw();
+ }
+ sel.mode = 1;
+ sel.ex = sel.bx = x2col(e->xbutton.x);
+ sel.ey = sel.by = y2row(e->xbutton.y);
+ } else if(e->xbutton.button == Button4) {
+ ttywrite("\031", 1);
+ } else if(e->xbutton.button == Button5) {
+ ttywrite("\005", 1);
+ }
+}
+
+void
+selcopy(void) {
+ char *str, *ptr, *p;
+ int x, y, bufsize, is_selected = 0, size;
+ Glyph *gp, *last;
+
+ if(sel.bx == -1) {
+ str = NULL;
+ } else {
+ bufsize = (term.col+1) * (sel.e.y-sel.b.y+1) * UTF_SIZ;
+ ptr = str = xmalloc(bufsize);
+
+ /* append every set & selected glyph to the selection */
+ for(y = 0; y < term.row; y++) {
+ gp = &term.line[y][0];
+ last = gp + term.col;
+
+ while(--last >= gp && !(last->state & GLYPH_SET))
+ /* nothing */;
+
+ for(x = 0; gp <= last; x++, ++gp) {
+ if(!(is_selected = selected(x, y)))
+ continue;
+
+ p = (gp->state & GLYPH_SET) ? gp->c : " ";
+ size = utf8size(p);
+ memcpy(ptr, p, size);
+ ptr += size;
+ }
+ /* \n at the end of every selected line except for the last one */
+ if(is_selected && y < sel.e.y)
+ *ptr++ = '\n';
+ }
+ *ptr = 0;
+ }
+ xsetsel(str);
+}
+
+void
+selnotify(XEvent *e) {
+ ulong nitems, ofs, rem;
+ int format;
+ uchar *data;
+ Atom type;
+
+ ofs = 0;
+ do {
+ if(XGetWindowProperty(xw.dpy, xw.win, XA_PRIMARY, ofs, BUFSIZ/4,
+ False, AnyPropertyType, &type, &format,
+ &nitems, &rem, &data)) {
+ fprintf(stderr, "Clipboard allocation failed\n");
+ return;
+ }
+ ttywrite((const char *) data, nitems * format / 8);
+ XFree(data);
+ /* number of 32-bit chunks returned */
+ ofs += nitems * format / 32;
+ } while(rem > 0);
+}
+
+void
+selpaste(const Arg *dummy) {
+ XConvertSelection(xw.dpy, XA_PRIMARY, sel.xtarget, XA_PRIMARY,
+ xw.win, CurrentTime);
+}
+
+void selclear(XEvent *e) {
+ if(sel.bx == -1)
+ return;
+ sel.bx = -1;
+ tsetdirt(sel.b.y, sel.e.y);
+}
+
+void
+selrequest(XEvent *e) {
+ XSelectionRequestEvent *xsre;
+ XSelectionEvent xev;
+ Atom xa_targets, string;
+
+ xsre = (XSelectionRequestEvent *) e;
+ xev.type = SelectionNotify;
+ xev.requestor = xsre->requestor;
+ xev.selection = xsre->selection;
+ xev.target = xsre->target;
+ xev.time = xsre->time;
+ /* reject */
+ xev.property = None;
+
+ xa_targets = XInternAtom(xw.dpy, "TARGETS", 0);
+ if(xsre->target == xa_targets) {
+ /* respond with the supported type */
+ string = sel.xtarget;
+ XChangeProperty(xsre->display, xsre->requestor, xsre->property,
+ XA_ATOM, 32, PropModeReplace,
+ (uchar *) &string, 1);
+ xev.property = xsre->property;
+ } else if(xsre->target == sel.xtarget && sel.clip != NULL) {
+ XChangeProperty(xsre->display, xsre->requestor, xsre->property,
+ xsre->target, 8, PropModeReplace,
+ (uchar *) sel.clip, strlen(sel.clip));
+ xev.property = xsre->property;
+ }
+
+ /* all done, send a notification to the listener */
+ if(!XSendEvent(xsre->display, xsre->requestor, True, 0, (XEvent *) &xev))
+ fprintf(stderr, "Error sending SelectionNotify event\n");
+}
+
+void
+xsetsel(char *str) {
+ /* register the selection for both the clipboard and the primary */
+ Atom clipboard;
+
+ free(sel.clip);
+ sel.clip = str;
+
+ XSetSelectionOwner(xw.dpy, XA_PRIMARY, xw.win, CurrentTime);
+
+ clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
+ XSetSelectionOwner(xw.dpy, clipboard, xw.win, CurrentTime);
+}
+
+void
+brelease(XEvent *e) {
+ struct timeval now;
+
+ if(IS_SET(MODE_MOUSE)) {
+ mousereport(e);
+ return;
+ }
+
+ if(e->xbutton.button == Button2) {
+ selpaste(NULL);
+ } else if(e->xbutton.button == Button1) {
+ sel.mode = 0;
+ getbuttoninfo(e);
+ term.dirty[sel.ey] = 1;
+ if(sel.bx == sel.ex && sel.by == sel.ey) {
+ sel.bx = -1;
+ gettimeofday(&now, NULL);
+
+ if(TIMEDIFF(now, sel.tclick2) <= tripleclicktimeout) {
+ /* triple click on the line */
+ sel.b.x = sel.bx = 0;
+ sel.e.x = sel.ex = term.col;
+ sel.b.y = sel.e.y = sel.ey;
+ selcopy();
+ } else if(TIMEDIFF(now, sel.tclick1) <= doubleclicktimeout) {
+ /* double click to select word */
+ sel.bx = sel.ex;
+ while(sel.bx > 0 && term.line[sel.ey][sel.bx-1].state & GLYPH_SET &&
+ term.line[sel.ey][sel.bx-1].c[0] != ' ') {
+ sel.bx--;
+ }
+ sel.b.x = sel.bx;
+ while(sel.ex < term.col-1 && term.line[sel.ey][sel.ex+1].state & GLYPH_SET &&
+ term.line[sel.ey][sel.ex+1].c[0] != ' ') {
+ sel.ex++;
+ }
+ sel.e.x = sel.ex;
+ sel.b.y = sel.e.y = sel.ey;
+ selcopy();
+ }
+ } else {
+ selcopy();
+ }
+ }
+
+ memcpy(&sel.tclick2, &sel.tclick1, sizeof(struct timeval));
+ gettimeofday(&sel.tclick1, NULL);
+}
+
+void
+bmotion(XEvent *e) {
+ int starty, endy, oldey, oldex;
+
+ if(IS_SET(MODE_MOUSE)) {
+ mousereport(e);
+ return;
+ }
+
+ if(!sel.mode)
+ return;
+
+ oldey = sel.ey;
+ oldex = sel.ex;
+ getbuttoninfo(e);
+
+ if(oldey != sel.ey || oldex != sel.ex) {
+ starty = MIN(oldey, sel.ey);
+ endy = MAX(oldey, sel.ey);
+ tsetdirt(starty, endy);
+ }
+}
+
+void
+die(const char *errstr, ...) {
+ va_list ap;
+
+ va_start(ap, errstr);
+ vfprintf(stderr, errstr, ap);
+ va_end(ap);
+ exit(EXIT_FAILURE);
+}
+
+void
+execsh(void) {
+ char **args;
+ char *envshell = getenv("SHELL");
+ const struct passwd *pass = getpwuid(getuid());
+ char buf[sizeof(long) * 8 + 1];
+
+ unsetenv("COLUMNS");
+ unsetenv("LINES");
+ unsetenv("TERMCAP");
+
+ if(pass) {
+ setenv("LOGNAME", pass->pw_name, 1);
+ setenv("USER", pass->pw_name, 1);
+ setenv("SHELL", pass->pw_shell, 0);
+ setenv("HOME", pass->pw_dir, 0);
+ }
+
+ snprintf(buf, sizeof(buf), "%lu", xw.win);
+ setenv("WINDOWID", buf, 1);
+
+ signal(SIGCHLD, SIG_DFL);
+ signal(SIGHUP, SIG_DFL);
+ signal(SIGINT, SIG_DFL);
+ signal(SIGQUIT, SIG_DFL);
+ signal(SIGTERM, SIG_DFL);
+ signal(SIGALRM, SIG_DFL);
+
+ DEFAULT(envshell, shell);
+ setenv("TERM", termname, 1);
+ args = opt_cmd ? opt_cmd : (char *[]){envshell, "-i", NULL};
+ execvp(args[0], args);
+ exit(EXIT_FAILURE);
+}
+
+void
+sigchld(int a) {
+ int stat = 0;
+
+ if(waitpid(pid, &stat, 0) < 0)
+ die("Waiting for pid %hd failed: %s\n", pid, SERRNO);
+
+ if(WIFEXITED(stat)) {
+ exit(WEXITSTATUS(stat));
+ } else {
+ exit(EXIT_FAILURE);
+ }
+}
+
+void
+ttynew(void) {
+ int m, s;
+ struct winsize w = {term.row, term.col, 0, 0};
+
+ /* seems to work fine on linux, openbsd and freebsd */
+ if(openpty(&m, &s, NULL, NULL, &w) < 0)
+ die("openpty failed: %s\n", SERRNO);
+
+ switch(pid = fork()) {
+ case -1:
+ die("fork failed\n");
+ break;
+ case 0:
+ setsid(); /* create a new process group */
+ dup2(s, STDIN_FILENO);
+ dup2(s, STDOUT_FILENO);
+ dup2(s, STDERR_FILENO);
+ if(ioctl(s, TIOCSCTTY, NULL) < 0)
+ die("ioctl TIOCSCTTY failed: %s\n", SERRNO);
+ close(s);
+ close(m);
+ execsh();
+ break;
+ default:
+ close(s);
+ cmdfd = m;
+ signal(SIGCHLD, sigchld);
+ if(opt_io) {
+ iofd = (!strcmp(opt_io, "-")) ?
+ STDOUT_FILENO :
+ open(opt_io, O_WRONLY | O_CREAT, 0666);
+ if(iofd < 0) {
+ fprintf(stderr, "Error opening %s:%s\n",
+ opt_io, strerror(errno));
+ }
+ }
+ }
+}
+
+void
+dump(char c) {
+ static int col;
+
+ fprintf(stderr, " %02x '%c' ", c, isprint(c)?c:'.');
+ if(++col % 10 == 0)
+ fprintf(stderr, "\n");
+}
+
+void
+ttyread(void) {
+ static char buf[BUFSIZ];
+ static int buflen = 0;
+ char *ptr;
+ char s[UTF_SIZ];
+ int charsize; /* size of utf8 char in bytes */
+ long utf8c;
+ int ret;
+
+ /* append read bytes to unprocessed bytes */
+ if((ret = read(cmdfd, buf+buflen, LEN(buf)-buflen)) < 0)
+ die("Couldn't read from shell: %s\n", SERRNO);
+
+ /* process every complete utf8 char */
+ buflen += ret;
+ ptr = buf;
+ while(buflen >= UTF_SIZ || isfullutf8(ptr,buflen)) {
+ charsize = utf8decode(ptr, &utf8c);
+ utf8encode(&utf8c, s);
+ tputc(s, charsize);
+ ptr += charsize;
+ buflen -= charsize;
+ }
+
+ /* keep any uncomplete utf8 char for the next call */
+ memmove(buf, ptr, buflen);
+}
+
+void
+ttywrite(const char *s, size_t n) {
+ if(write(cmdfd, s, n) == -1)
+ die("write error on tty: %s\n", SERRNO);
+}
+
+void
+ttyresize(void) {
+ struct winsize w;
+
+ w.ws_row = term.row;
+ w.ws_col = term.col;
+ w.ws_xpixel = xw.tw;
+ w.ws_ypixel = xw.th;
+ if(ioctl(cmdfd, TIOCSWINSZ, &w) < 0)
+ fprintf(stderr, "Couldn't set window size: %s\n", SERRNO);
+}
+
+void
+tsetdirt(int top, int bot) {
+ int i;
+
+ LIMIT(top, 0, term.row-1);
+ LIMIT(bot, 0, term.row-1);
+
+ for(i = top; i <= bot; i++)
+ term.dirty[i] = 1;
+}
+
+void
+tfulldirt(void) {
+ tsetdirt(0, term.row-1);
+}
+
+void
+tcursor(int mode) {
+ static TCursor c;
+
+ if(mode == CURSOR_SAVE) {
+ c = term.c;
+ } else if(mode == CURSOR_LOAD) {
+ term.c = c;
+ tmoveto(c.x, c.y);
+ }
+}
+
+void
+treset(void) {
+ uint i;
+
+ term.c = (TCursor){{
+ .mode = ATTR_NULL,
+ .fg = defaultfg,
+ .bg = defaultbg
+ }, .x = 0, .y = 0, .state = CURSOR_DEFAULT};
+
+ memset(term.tabs, 0, term.col * sizeof(*term.tabs));
+ for(i = tabspaces; i < term.col; i += tabspaces)
+ term.tabs[i] = 1;
+ term.top = 0;
+ term.bot = term.row - 1;
+ term.mode = MODE_WRAP;
+
+ tclearregion(0, 0, term.col-1, term.row-1, 0);
+ tmoveto(0, 0);
+ tcursor(CURSOR_SAVE);
+}
+
+void
+tnew(int col, int row) {
+ /* set screen size */
+ term.row = row;
+ term.col = col;
+ term.line = xmalloc(term.row * sizeof(Line));
+ term.alt = xmalloc(term.row * sizeof(Line));
+ term.dirty = xmalloc(term.row * sizeof(*term.dirty));
+ term.tabs = xmalloc(term.col * sizeof(*term.tabs));
+
+ for(row = 0; row < term.row; row++) {
+ term.line[row] = xmalloc(term.col * sizeof(Glyph));
+ term.alt [row] = xmalloc(term.col * sizeof(Glyph));
+ term.dirty[row] = 0;
+ }
+
+ term.numlock = 1;
+ memset(term.tabs, 0, term.col * sizeof(*term.tabs));
+ /* setup screen */
+ treset();
+}
+
+void
+tswapscreen(void) {
+ Line *tmp = term.line;
+
+ term.line = term.alt;
+ term.alt = tmp;
+ term.mode ^= MODE_ALTSCREEN;
+ tfulldirt();
+}
+
+void
+tscrolldown(int orig, int n) {
+ int i;
+ Line temp;
+
+ LIMIT(n, 0, term.bot-orig+1);
+
+ tclearregion(0, term.bot-n+1, term.col-1, term.bot, 0);
+
+ for(i = term.bot; i >= orig+n; i--) {
+ temp = term.line[i];
+ term.line[i] = term.line[i-n];
+ term.line[i-n] = temp;
+
+ term.dirty[i] = 1;
+ term.dirty[i-n] = 1;
+ }
+
+ selscroll(orig, n);
+}
+
+void
+tscrollup(int orig, int n) {
+ int i;
+ Line temp;
+ LIMIT(n, 0, term.bot-orig+1);
+
+ tclearregion(0, orig, term.col-1, orig+n-1, 0);
+
+ for(i = orig; i <= term.bot-n; i++) {
+ temp = term.line[i];
+ term.line[i] = term.line[i+n];
+ term.line[i+n] = temp;
+
+ term.dirty[i] = 1;
+ term.dirty[i+n] = 1;
+ }
+
+ selscroll(orig, -n);
+}
+
+void
+selscroll(int orig, int n) {
+ if(sel.bx == -1)
+ return;
+
+ if(BETWEEN(sel.by, orig, term.bot) || BETWEEN(sel.ey, orig, term.bot)) {
+ if((sel.by += n) > term.bot || (sel.ey += n) < term.top) {
+ sel.bx = -1;
+ return;
+ }
+ if(sel.by < term.top) {
+ sel.by = term.top;
+ sel.bx = 0;
+ }
+ if(sel.ey > term.bot) {
+ sel.ey = term.bot;
+ sel.ex = term.col;
+ }
+ sel.b.y = sel.by, sel.b.x = sel.bx;
+ sel.e.y = sel.ey, sel.e.x = sel.ex;
+ }
+}
+
+void
+tnewline(int first_col) {
+ int y = term.c.y;
+
+ if(y == term.bot) {
+ tscrollup(term.top, 1);
+ } else {
+ y++;
+ }
+ tmoveto(first_col ? 0 : term.c.x, y);
+}
+
+void
+csiparse(void) {
+ /* int noarg = 1; */
+ char *p = csiescseq.buf;
+
+ csiescseq.narg = 0;
+ if(*p == '?')
+ csiescseq.priv = 1, p++;
+
+ while(p < csiescseq.buf+csiescseq.len) {
+ while(isdigit(*p)) {
+ csiescseq.arg[csiescseq.narg] *= 10;
+ csiescseq.arg[csiescseq.narg] += *p++ - '0'/*, noarg = 0 */;
+ }
+ if(*p == ';' && csiescseq.narg+1 < ESC_ARG_SIZ) {
+ csiescseq.narg++, p++;
+ } else {
+ csiescseq.mode = *p;
+ csiescseq.narg++;
+
+ return;
+ }
+ }
+}
+
+/* for absolute user moves, when decom is set */
+void
+tmoveato(int x, int y) {
+ tmoveto(x, y + ((term.c.state & CURSOR_ORIGIN) ? term.top: 0));
+}
+
+void
+tmoveto(int x, int y) {
+ int miny, maxy;
+
+ if(term.c.state & CURSOR_ORIGIN) {
+ miny = term.top;
+ maxy = term.bot;
+ } else {
+ miny = 0;
+ maxy = term.row - 1;
+ }
+ LIMIT(x, 0, term.col-1);
+ LIMIT(y, miny, maxy);
+ term.c.state &= ~CURSOR_WRAPNEXT;
+ term.c.x = x;
+ term.c.y = y;
+}
+
+void
+tsetchar(char *c, Glyph *attr, int x, int y) {
+ static char *vt100_0[62] = { /* 0x41 - 0x7e */
+ "↑", "↓", "→", "←", "█", "▚", "☃", /* A - G */
+ 0, 0, 0, 0, 0, 0, 0, 0, /* H - O */
+ 0, 0, 0, 0, 0, 0, 0, 0, /* P - W */
+ 0, 0, 0, 0, 0, 0, 0, " ", /* X - _ */
+ "◆", "▒", "␉", "␌", "␍", "␊", "°", "±", /* ` - g */
+ "", "␋", "┘", "┐", "┌", "└", "┼", "⎺", /* h - o */
+ "⎻", "─", "⎼", "⎽", "├", "┤", "┴", "┬", /* p - w */
+ "│", "≤", "≥", "π", "≠", "£", "·", /* x - ~ */
+ };
+
+ /*
+ * The table is proudly stolen from rxvt.
+ */
+ if(attr->mode & ATTR_GFX) {
+ if(c[0] >= 0x41 && c[0] <= 0x7e
+ && vt100_0[c[0] - 0x41]) {
+ c = vt100_0[c[0] - 0x41];
+ }
+ }
+
+ term.dirty[y] = 1;
+ term.line[y][x] = *attr;
+ memcpy(term.line[y][x].c, c, UTF_SIZ);
+ term.line[y][x].state |= GLYPH_SET;
+}
+
+void
+tclearregion(int x1, int y1, int x2, int y2, int bce) {
+ int x, y, temp;
+
+ if(x1 > x2)
+ temp = x1, x1 = x2, x2 = temp;
+ if(y1 > y2)
+ temp = y1, y1 = y2, y2 = temp;
+
+ LIMIT(x1, 0, term.col-1);
+ LIMIT(x2, 0, term.col-1);
+ LIMIT(y1, 0, term.row-1);
+ LIMIT(y2, 0, term.row-1);
+
+ for(y = y1; y <= y2; y++) {
+ term.dirty[y] = 1;
+ for(x = x1; x <= x2; x++) {
+ if(bce) {
+ term.line[y][x] = term.c.attr;
+ memcpy(term.line[y][x].c, " ", 2);
+ term.line[y][x].state |= GLYPH_SET;
+ } else {
+ term.line[y][x].state = 0;
+ }
+ }
+ }
+}
+
+void
+tdeletechar(int n) {
+ int src = term.c.x + n;
+ int dst = term.c.x;
+ int size = term.col - src;
+
+ term.dirty[term.c.y] = 1;
+
+ if(src >= term.col) {
+ tclearregion(term.c.x, term.c.y, term.col-1, term.c.y, 0);
+ return;
+ }
+
+ memmove(&term.line[term.c.y][dst], &term.line[term.c.y][src],
+ size * sizeof(Glyph));
+ tclearregion(term.col-n, term.c.y, term.col-1, term.c.y, 0);
+}
+
+void
+tinsertblank(int n) {
+ int src = term.c.x;
+ int dst = src + n;
+ int size = term.col - dst;
+
+ term.dirty[term.c.y] = 1;
+
+ if(dst >= term.col) {
+ tclearregion(term.c.x, term.c.y, term.col-1, term.c.y, 0);
+ return;
+ }
+
+ memmove(&term.line[term.c.y][dst], &term.line[term.c.y][src],
+ size * sizeof(Glyph));
+ tclearregion(src, term.c.y, dst - 1, term.c.y, 0);
+}
+
+void
+tinsertblankline(int n) {
+ if(term.c.y < term.top || term.c.y > term.bot)
+ return;
+
+ tscrolldown(term.c.y, n);
+}
+
+void
+tdeleteline(int n) {
+ if(term.c.y < term.top || term.c.y > term.bot)
+ return;
+
+ tscrollup(term.c.y, n);
+}
+
+void
+tsetattr(int *attr, int l) {
+ int i;
+
+ for(i = 0; i < l; i++) {
+ switch(attr[i]) {
+ case 0:
+ term.c.attr.mode &= ~(ATTR_REVERSE | ATTR_UNDERLINE | ATTR_BOLD \
+ | ATTR_ITALIC | ATTR_BLINK);
+ term.c.attr.fg = defaultfg;
+ term.c.attr.bg = defaultbg;
+ break;
+ case 1:
+ term.c.attr.mode |= ATTR_BOLD;
+ break;
+ case 3:
+ term.c.attr.mode |= ATTR_ITALIC;
+ break;
+ case 4:
+ term.c.attr.mode |= ATTR_UNDERLINE;
+ break;
+ case 5: /* slow blink */
+ case 6: /* rapid blink */
+ term.c.attr.mode |= ATTR_BLINK;
+ break;
+ case 7:
+ term.c.attr.mode |= ATTR_REVERSE;
+ break;
+ case 21:
+ case 22:
+ term.c.attr.mode &= ~ATTR_BOLD;
+ break;
+ case 23:
+ term.c.attr.mode &= ~ATTR_ITALIC;
+ break;
+ case 24:
+ term.c.attr.mode &= ~ATTR_UNDERLINE;
+ break;
+ case 25:
+ case 26:
+ term.c.attr.mode &= ~ATTR_BLINK;
+ break;
+ case 27:
+ term.c.attr.mode &= ~ATTR_REVERSE;
+ break;
+ case 38:
+ if(i + 2 < l && attr[i + 1] == 5) {
+ i += 2;
+ if(BETWEEN(attr[i], 0, 255)) {
+ term.c.attr.fg = attr[i];
+ } else {
+ fprintf(stderr,
+ "erresc: bad fgcolor %d\n",
+ attr[i]);
+ }
+ } else {
+ fprintf(stderr,
+ "erresc(38): gfx attr %d unknown\n",
+ attr[i]);
+ }
+ break;
+ case 39:
+ term.c.attr.fg = defaultfg;
+ break;
+ case 48:
+ if(i + 2 < l && attr[i + 1] == 5) {
+ i += 2;
+ if(BETWEEN(attr[i], 0, 255)) {
+ term.c.attr.bg = attr[i];
+ } else {
+ fprintf(stderr,
+ "erresc: bad bgcolor %d\n",
+ attr[i]);
+ }
+ } else {
+ fprintf(stderr,
+ "erresc(48): gfx attr %d unknown\n",
+ attr[i]);
+ }
+ break;
+ case 49:
+ term.c.attr.bg = defaultbg;
+ break;
+ default:
+ if(BETWEEN(attr[i], 30, 37)) {
+ term.c.attr.fg = attr[i] - 30;
+ } else if(BETWEEN(attr[i], 40, 47)) {
+ term.c.attr.bg = attr[i] - 40;
+ } else if(BETWEEN(attr[i], 90, 97)) {
+ term.c.attr.fg = attr[i] - 90 + 8;
+ } else if(BETWEEN(attr[i], 100, 107)) {
+ term.c.attr.bg = attr[i] - 100 + 8;
+ } else {
+ fprintf(stderr,
+ "erresc(default): gfx attr %d unknown\n",
+ attr[i]), csidump();
+ }
+ break;
+ }
+ }
+}
+
+void
+tsetscroll(int t, int b) {
+ int temp;
+
+ LIMIT(t, 0, term.row-1);
+ LIMIT(b, 0, term.row-1);
+ if(t > b) {
+ temp = t;
+ t = b;
+ b = temp;
+ }
+ term.top = t;
+ term.bot = b;
+}
+
+#define MODBIT(x, set, bit) ((set) ? ((x) |= (bit)) : ((x) &= ~(bit)))
+
+void
+tsetmode(bool priv, bool set, int *args, int narg) {
+ int *lim, mode;
+ bool alt;
+
+ for(lim = args + narg; args < lim; ++args) {
+ if(priv) {
+ switch(*args) {
+ break;
+ case 1: /* DECCKM -- Cursor key */
+ MODBIT(term.mode, set, MODE_APPCURSOR);
+ break;
+ case 5: /* DECSCNM -- Reverse video */
+ mode = term.mode;
+ MODBIT(term.mode, set, MODE_REVERSE);
+ if(mode != term.mode)
+ redraw(REDRAW_TIMEOUT);
+ break;
+ case 6: /* DECOM -- Origin */
+ MODBIT(term.c.state, set, CURSOR_ORIGIN);
+ tmoveato(0, 0);
+ break;
+ case 7: /* DECAWM -- Auto wrap */
+ MODBIT(term.mode, set, MODE_WRAP);
+ break;
+ case 0: /* Error (IGNORED) */
+ case 2: /* DECANM -- ANSI/VT52 (IGNORED) */
+ case 3: /* DECCOLM -- Column (IGNORED) */
+ case 4: /* DECSCLM -- Scroll (IGNORED) */
+ case 8: /* DECARM -- Auto repeat (IGNORED) */
+ case 18: /* DECPFF -- Printer feed (IGNORED) */
+ case 19: /* DECPEX -- Printer extent (IGNORED) */
+ case 42: /* DECNRCM -- National characters (IGNORED) */
+ case 12: /* att610 -- Start blinking cursor (IGNORED) */
+ break;
+ case 25: /* DECTCEM -- Text Cursor Enable Mode */
+ MODBIT(term.mode, !set, MODE_HIDE);
+ break;
+ case 1000: /* 1000,1002: enable xterm mouse report */
+ MODBIT(term.mode, set, MODE_MOUSEBTN);
+ MODBIT(term.mode, 0, MODE_MOUSEMOTION);
+ break;
+ case 1002:
+ MODBIT(term.mode, set, MODE_MOUSEMOTION);
+ MODBIT(term.mode, 0, MODE_MOUSEBTN);
+ break;
+ case 1006:
+ MODBIT(term.mode, set, MODE_MOUSESGR);
+ break;
+ case 1049: /* = 1047 and 1048 */
+ case 47:
+ case 1047: {
+ alt = IS_SET(MODE_ALTSCREEN);
+ if(alt) {
+ tclearregion(0, 0, term.col-1,
+ term.row-1, 0);
+ }
+ if(set ^ alt) /* set is always 1 or 0 */
+ tswapscreen();
+ if(*args != 1049)
+ break;
+ }
+ /* pass through */
+ case 1048:
+ tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD);
+ break;
+ default:
+ fprintf(stderr,
+ "erresc: unknown private set/reset mode %d\n",
+ *args);
+ break;
+ }
+ } else {
+ switch(*args) {
+ case 0: /* Error (IGNORED) */
+ break;
+ case 2: /* KAM -- keyboard action */
+ MODBIT(term.mode, set, MODE_KBDLOCK);
+ break;
+ case 4: /* IRM -- Insertion-replacement */
+ MODBIT(term.mode, set, MODE_INSERT);
+ break;
+ case 12: /* SRM -- Send/Receive */
+ MODBIT(term.mode, !set, MODE_ECHO);
+ break;
+ case 20: /* LNM -- Linefeed/new line */
+ MODBIT(term.mode, set, MODE_CRLF);
+ break;
+ default:
+ fprintf(stderr,
+ "erresc: unknown set/reset mode %d\n",
+ *args);
+ break;
+ }
+ }
+ }
+}
+#undef MODBIT
+
+
+void
+csihandle(void) {
+ switch(csiescseq.mode) {
+ default:
+ unknown:
+ fprintf(stderr, "erresc: unknown csi ");
+ csidump();
+ /* die(""); */
+ break;
+ case '@': /* ICH -- Insert <n> blank char */
+ DEFAULT(csiescseq.arg[0], 1);
+ tinsertblank(csiescseq.arg[0]);
+ break;
+ case 'A': /* CUU -- Cursor <n> Up */
+ DEFAULT(csiescseq.arg[0], 1);
+ tmoveto(term.c.x, term.c.y-csiescseq.arg[0]);
+ break;
+ case 'B': /* CUD -- Cursor <n> Down */
+ case 'e': /* VPR --Cursor <n> Down */
+ DEFAULT(csiescseq.arg[0], 1);
+ tmoveto(term.c.x, term.c.y+csiescseq.arg[0]);
+ break;
+ case 'c': /* DA -- Device Attributes */
+ if(csiescseq.arg[0] == 0)
+ ttywrite(VT102ID, sizeof(VT102ID) - 1);
+ break;
+ case 'C': /* CUF -- Cursor <n> Forward */
+ case 'a': /* HPR -- Cursor <n> Forward */
+ DEFAULT(csiescseq.arg[0], 1);
+ tmoveto(term.c.x+csiescseq.arg[0], term.c.y);
+ break;
+ case 'D': /* CUB -- Cursor <n> Backward */
+ DEFAULT(csiescseq.arg[0], 1);
+ tmoveto(term.c.x-csiescseq.arg[0], term.c.y);
+ break;
+ case 'E': /* CNL -- Cursor <n> Down and first col */
+ DEFAULT(csiescseq.arg[0], 1);
+ tmoveto(0, term.c.y+csiescseq.arg[0]);
+ break;
+ case 'F': /* CPL -- Cursor <n> Up and first col */
+ DEFAULT(csiescseq.arg[0], 1);
+ tmoveto(0, term.c.y-csiescseq.arg[0]);
+ break;
+ case 'g': /* TBC -- Tabulation clear */
+ switch (csiescseq.arg[0]) {
+ case 0: /* clear current tab stop */
+ term.tabs[term.c.x] = 0;
+ break;
+ case 3: /* clear all the tabs */
+ memset(term.tabs, 0, term.col * sizeof(*term.tabs));
+ break;
+ default:
+ goto unknown;
+ }
+ break;
+ case 'G': /* CHA -- Move to <col> */
+ case '`': /* HPA */
+ DEFAULT(csiescseq.arg[0], 1);
+ tmoveto(csiescseq.arg[0]-1, term.c.y);
+ break;
+ case 'H': /* CUP -- Move to <row> <col> */
+ case 'f': /* HVP */
+ DEFAULT(csiescseq.arg[0], 1);
+ DEFAULT(csiescseq.arg[1], 1);
+ tmoveato(csiescseq.arg[1]-1, csiescseq.arg[0]-1);
+ break;
+ case 'I': /* CHT -- Cursor Forward Tabulation <n> tab stops */
+ DEFAULT(csiescseq.arg[0], 1);
+ while(csiescseq.arg[0]--)
+ tputtab(1);
+ break;
+ case 'J': /* ED -- Clear screen */
+ sel.bx = -1;
+ switch(csiescseq.arg[0]) {
+ case 0: /* below */
+ tclearregion(term.c.x, term.c.y, term.col-1, term.c.y, 1);
+ if(term.c.y < term.row-1) {
+ tclearregion(0, term.c.y+1, term.col-1,
+ term.row-1, 1);
+ }
+ break;
+ case 1: /* above */
+ if(term.c.y > 1)
+ tclearregion(0, 0, term.col-1, term.c.y-1, 1);
+ tclearregion(0, term.c.y, term.c.x, term.c.y, 1);
+ break;
+ case 2: /* all */
+ tclearregion(0, 0, term.col-1, term.row-1, 1);
+ break;
+ default:
+ goto unknown;
+ }
+ break;
+ case 'K': /* EL -- Clear line */
+ switch(csiescseq.arg[0]) {
+ case 0: /* right */
+ tclearregion(term.c.x, term.c.y, term.col-1,
+ term.c.y, 1);
+ break;
+ case 1: /* left */
+ tclearregion(0, term.c.y, term.c.x, term.c.y, 1);
+ break;
+ case 2: /* all */
+ tclearregion(0, term.c.y, term.col-1, term.c.y, 1);
+ break;
+ }
+ break;
+ case 'S': /* SU -- Scroll <n> line up */
+ DEFAULT(csiescseq.arg[0], 1);
+ tscrollup(term.top, csiescseq.arg[0]);
+ break;
+ case 'T': /* SD -- Scroll <n> line down */
+ DEFAULT(csiescseq.arg[0], 1);
+ tscrolldown(term.top, csiescseq.arg[0]);
+ break;
+ case 'L': /* IL -- Insert <n> blank lines */
+ DEFAULT(csiescseq.arg[0], 1);
+ tinsertblankline(csiescseq.arg[0]);
+ break;
+ case 'l': /* RM -- Reset Mode */
+ tsetmode(csiescseq.priv, 0, csiescseq.arg, csiescseq.narg);
+ break;
+ case 'M': /* DL -- Delete <n> lines */
+ DEFAULT(csiescseq.arg[0], 1);
+ tdeleteline(csiescseq.arg[0]);
+ break;
+ case 'X': /* ECH -- Erase <n> char */
+ DEFAULT(csiescseq.arg[0], 1);
+ tclearregion(term.c.x, term.c.y,
+ term.c.x + csiescseq.arg[0] - 1, term.c.y, 1);
+ break;
+ case 'P': /* DCH -- Delete <n> char */
+ DEFAULT(csiescseq.arg[0], 1);
+ tdeletechar(csiescseq.arg[0]);
+ break;
+ case 'Z': /* CBT -- Cursor Backward Tabulation <n> tab stops */
+ DEFAULT(csiescseq.arg[0], 1);
+ while(csiescseq.arg[0]--)
+ tputtab(0);
+ break;
+ case 'd': /* VPA -- Move to <row> */
+ DEFAULT(csiescseq.arg[0], 1);
+ tmoveato(term.c.x, csiescseq.arg[0]-1);
+ break;
+ case 'h': /* SM -- Set terminal mode */
+ tsetmode(csiescseq.priv, 1, csiescseq.arg, csiescseq.narg);
+ break;
+ case 'm': /* SGR -- Terminal attribute (color) */
+ tsetattr(csiescseq.arg, csiescseq.narg);
+ break;
+ case 'r': /* DECSTBM -- Set Scrolling Region */
+ if(csiescseq.priv) {
+ goto unknown;
+ } else {
+ DEFAULT(csiescseq.arg[0], 1);
+ DEFAULT(csiescseq.arg[1], term.row);
+ tsetscroll(csiescseq.arg[0]-1, csiescseq.arg[1]-1);
+ tmoveato(0, 0);
+ }
+ break;
+ case 's': /* DECSC -- Save cursor position (ANSI.SYS) */
+ tcursor(CURSOR_SAVE);
+ break;
+ case 'u': /* DECRC -- Restore cursor position (ANSI.SYS) */
+ tcursor(CURSOR_LOAD);
+ break;
+ }
+}
+
+void
+csidump(void) {
+ int i;
+ uint c;
+
+ printf("ESC[");
+ for(i = 0; i < csiescseq.len; i++) {
+ c = csiescseq.buf[i] & 0xff;
+ if(isprint(c)) {
+ putchar(c);
+ } else if(c == '\n') {
+ printf("(\\n)");
+ } else if(c == '\r') {
+ printf("(\\r)");
+ } else if(c == 0x1b) {
+ printf("(\\e)");
+ } else {
+ printf("(%02x)", c);
+ }
+ }
+ putchar('\n');
+}
+
+void
+csireset(void) {
+ memset(&csiescseq, 0, sizeof(csiescseq));
+}
+
+void
+strhandle(void) {
+ char *p;
+
+ /*
+ * TODO: make this being useful in case of color palette change.
+ */
+ strparse();
+
+ p = strescseq.buf;
+
+ switch(strescseq.type) {
+ case ']': /* OSC -- Operating System Command */
+ switch(p[0]) {
+ case '0':
+ case '1':
+ case '2':
+ /*
+ * TODO: Handle special chars in string, like umlauts.
+ */
+ if(p[1] == ';') {
+ XStoreName(xw.dpy, xw.win, strescseq.buf+2);
+ }
+ break;
+ case ';':
+ XStoreName(xw.dpy, xw.win, strescseq.buf+1);
+ break;
+ case '4': /* TODO: Set color (arg0) to "rgb:%hexr/$hexg/$hexb" (arg1) */
+ break;
+ default:
+ fprintf(stderr, "erresc: unknown str ");
+ strdump();
+ break;
+ }
+ break;
+ case 'k': /* old title set compatibility */
+ XStoreName(xw.dpy, xw.win, strescseq.buf);
+ break;
+ case 'P': /* DSC -- Device Control String */
+ case '_': /* APC -- Application Program Command */
+ case '^': /* PM -- Privacy Message */
+ default:
+ fprintf(stderr, "erresc: unknown str ");
+ strdump();
+ /* die(""); */
+ break;
+ }
+}
+
+void
+strparse(void) {
+ /*
+ * TODO: Implement parsing like for CSI when required.
+ * Format: ESC type cmd ';' arg0 [';' argn] ESC \
+ */
+ return;
+}
+
+void
+strdump(void) {
+ int i;
+ uint c;
+
+ printf("ESC%c", strescseq.type);
+ for(i = 0; i < strescseq.len; i++) {
+ c = strescseq.buf[i] & 0xff;
+ if(isprint(c)) {
+ putchar(c);
+ } else if(c == '\n') {
+ printf("(\\n)");
+ } else if(c == '\r') {
+ printf("(\\r)");
+ } else if(c == 0x1b) {
+ printf("(\\e)");
+ } else {
+ printf("(%02x)", c);
+ }
+ }
+ printf("ESC\\\n");
+}
+
+void
+strreset(void) {
+ memset(&strescseq, 0, sizeof(strescseq));
+}
+
+void
+tputtab(bool forward) {
+ uint x = term.c.x;
+
+ if(forward) {
+ if(x == term.col)
+ return;
+ for(++x; x < term.col && !term.tabs[x]; ++x)
+ /* nothing */ ;
+ } else {
+ if(x == 0)
+ return;
+ for(--x; x > 0 && !term.tabs[x]; --x)
+ /* nothing */ ;
+ }
+ tmoveto(x, term.c.y);
+}
+
+void
+techo(char *buf, int len) {
+ for(; len > 0; buf++, len--) {
+ char c = *buf;
+
+ if(c == '\033') { /* escape */
+ tputc("^", 1);
+ tputc("[", 1);
+ } else if (c < '\x20') { /* control code */
+ if(c != '\n' && c != '\r' && c != '\t') {
+ c |= '\x40';
+ tputc("^", 1);
+ }
+ tputc(&c, 1);
+ } else {
+ break;
+ }
+ }
+ if (len)
+ tputc(buf, len);
+}
+
+void
+tputc(char *c, int len) {
+ uchar ascii = *c;
+ bool control = ascii < '\x20' || ascii == 0177;
+
+ if(iofd != -1) {
+ if (xwrite(iofd, c, len) < 0) {
+ fprintf(stderr, "Error writing in %s:%s\n",
+ opt_io, strerror(errno));
+ close(iofd);
+ iofd = -1;
+ }
+ }
+
+ /*
+ * STR sequences must be checked before anything else
+ * because it can use some control codes as part of the sequence.
+ */
+ if(term.esc & ESC_STR) {
+ switch(ascii) {
+ case '\033':
+ term.esc = ESC_START | ESC_STR_END;
+ break;
+ case '\a': /* backwards compatibility to xterm */
+ term.esc = 0;
+ strhandle();
+ break;
+ default:
+ if(strescseq.len + len < sizeof(strescseq.buf)) {
+ memmove(&strescseq.buf[strescseq.len], c, len);
+ strescseq.len += len;
+ } else {
+ /*
+ * Here is a bug in terminals. If the user never sends
+ * some code to stop the str or esc command, then st
+ * will stop responding. But this is better than
+ * silently failing with unknown characters. At least
+ * then users will report back.
+ *
+ * In the case users ever get fixed, here is the code:
+ */
+ /*
+ * term.esc = 0;
+ * strhandle();
+ */
+ }
+ }
+ return;
+ }
+
+ /*
+ * Actions of control codes must be performed as soon they arrive
+ * because they can be embedded inside a control sequence, and
+ * they must not cause conflicts with sequences.
+ */
+ if(control) {
+ switch(ascii) {
+ case '\t': /* HT */
+ tputtab(1);
+ return;
+ case '\b': /* BS */
+ tmoveto(term.c.x-1, term.c.y);
+ return;
+ case '\r': /* CR */
+ tmoveto(0, term.c.y);
+ return;
+ case '\f': /* LF */
+ case '\v': /* VT */
+ case '\n': /* LF */
+ /* go to first col if the mode is set */
+ tnewline(IS_SET(MODE_CRLF));
+ return;
+ case '\a': /* BEL */
+ if(!(xw.state & WIN_FOCUSED))
+ xseturgency(1);
+ return;
+ case '\033': /* ESC */
+ csireset();
+ term.esc = ESC_START;
+ return;
+ case '\016': /* SO */
+ case '\017': /* SI */
+ /*
+ * Different charsets are hard to handle. Applications
+ * should use the right alt charset escapes for the
+ * only reason they still exist: line drawing. The
+ * rest is incompatible history st should not support.
+ */
+ return;
+ case '\032': /* SUB */
+ case '\030': /* CAN */
+ csireset();
+ return;
+ case '\005': /* ENQ (IGNORED) */
+ case '\000': /* NUL (IGNORED) */
+ case '\021': /* XON (IGNORED) */
+ case '\023': /* XOFF (IGNORED) */
+ case 0177: /* DEL (IGNORED) */
+ return;
+ }
+ } else if(term.esc & ESC_START) {
+ if(term.esc & ESC_CSI) {
+ csiescseq.buf[csiescseq.len++] = ascii;
+ if(BETWEEN(ascii, 0x40, 0x7E)
+ || csiescseq.len >= ESC_BUF_SIZ) {
+ term.esc = 0;
+ csiparse(), csihandle();
+ }
+ } else if(term.esc & ESC_STR_END) {
+ term.esc = 0;
+ if(ascii == '\\')
+ strhandle();
+ } else if(term.esc & ESC_ALTCHARSET) {
+ switch(ascii) {
+ case '0': /* Line drawing set */
+ term.c.attr.mode |= ATTR_GFX;
+ break;
+ case 'B': /* USASCII */
+ term.c.attr.mode &= ~ATTR_GFX;
+ break;
+ case 'A': /* UK (IGNORED) */
+ case '<': /* multinational charset (IGNORED) */
+ case '5': /* Finnish (IGNORED) */
+ case 'C': /* Finnish (IGNORED) */
+ case 'K': /* German (IGNORED) */
+ break;
+ default:
+ fprintf(stderr, "esc unhandled charset: ESC ( %c\n", ascii);
+ }
+ term.esc = 0;
+ } else if(term.esc & ESC_TEST) {
+ if(ascii == '8') { /* DEC screen alignment test. */
+ char E[UTF_SIZ] = "E";
+ int x, y;
+
+ for(x = 0; x < term.col; ++x) {
+ for(y = 0; y < term.row; ++y)
+ tsetchar(E, &term.c.attr, x, y);
+ }
+ }
+ term.esc = 0;
+ } else {
+ switch(ascii) {
+ case '[':
+ term.esc |= ESC_CSI;
+ break;
+ case '#':
+ term.esc |= ESC_TEST;
+ break;
+ case 'P': /* DCS -- Device Control String */
+ case '_': /* APC -- Application Program Command */
+ case '^': /* PM -- Privacy Message */
+ case ']': /* OSC -- Operating System Command */
+ case 'k': /* old title set compatibility */
+ strreset();
+ strescseq.type = ascii;
+ term.esc |= ESC_STR;
+ break;
+ case '(': /* set primary charset G0 */
+ term.esc |= ESC_ALTCHARSET;
+ break;
+ case ')': /* set secondary charset G1 (IGNORED) */
+ case '*': /* set tertiary charset G2 (IGNORED) */
+ case '+': /* set quaternary charset G3 (IGNORED) */
+ term.esc = 0;
+ break;
+ case 'D': /* IND -- Linefeed */
+ if(term.c.y == term.bot) {
+ tscrollup(term.top, 1);
+ } else {
+ tmoveto(term.c.x, term.c.y+1);
+ }
+ term.esc = 0;
+ break;
+ case 'E': /* NEL -- Next line */
+ tnewline(1); /* always go to first col */
+ term.esc = 0;
+ break;
+ case 'H': /* HTS -- Horizontal tab stop */
+ term.tabs[term.c.x] = 1;
+ term.esc = 0;
+ break;
+ case 'M': /* RI -- Reverse index */
+ if(term.c.y == term.top) {
+ tscrolldown(term.top, 1);
+ } else {
+ tmoveto(term.c.x, term.c.y-1);
+ }
+ term.esc = 0;
+ break;
+ case 'Z': /* DECID -- Identify Terminal */
+ ttywrite(VT102ID, sizeof(VT102ID) - 1);
+ term.esc = 0;
+ break;
+ case 'c': /* RIS -- Reset to inital state */
+ treset();
+ term.esc = 0;
+ xresettitle();
+ break;
+ case '=': /* DECPAM -- Application keypad */
+ term.mode |= MODE_APPKEYPAD;
+ term.esc = 0;
+ break;
+ case '>': /* DECPNM -- Normal keypad */
+ term.mode &= ~MODE_APPKEYPAD;
+ term.esc = 0;
+ break;
+ case '7': /* DECSC -- Save Cursor */
+ tcursor(CURSOR_SAVE);
+ term.esc = 0;
+ break;
+ case '8': /* DECRC -- Restore Cursor */
+ tcursor(CURSOR_LOAD);
+ term.esc = 0;
+ break;
+ case '\\': /* ST -- Stop */
+ term.esc = 0;
+ break;
+ default:
+ fprintf(stderr, "erresc: unknown sequence ESC 0x%02X '%c'\n",
+ (uchar) ascii, isprint(ascii)? ascii:'.');
+ term.esc = 0;
+ }
+ }
+ /*
+ * All characters which form part of a sequence are not
+ * printed
+ */
+ return;
+ }
+ /*
+ * Display control codes only if we are in graphic mode
+ */
+ if(control && !(term.c.attr.mode & ATTR_GFX))
+ return;
+ if(sel.bx != -1 && BETWEEN(term.c.y, sel.by, sel.ey))
+ sel.bx = -1;
+ if(IS_SET(MODE_WRAP) && term.c.state & CURSOR_WRAPNEXT)
+ tnewline(1); /* always go to first col */
+
+ if(IS_SET(MODE_INSERT) && term.c.x+1 < term.col) {
+ memmove(&term.line[term.c.y][term.c.x+1],
+ &term.line[term.c.y][term.c.x],
+ (term.col - term.c.x - 1) * sizeof(Glyph));
+ }
+
+ tsetchar(c, &term.c.attr, term.c.x, term.c.y);
+ if(term.c.x+1 < term.col) {
+ tmoveto(term.c.x+1, term.c.y);
+ } else {
+ term.c.state |= CURSOR_WRAPNEXT;
+ }
+}
+
+int
+tresize(int col, int row) {
+ int i, x;
+ int minrow = MIN(row, term.row);
+ int mincol = MIN(col, term.col);
+ int slide = term.c.y - row + 1;
+ bool *bp;
+
+ if(col < 1 || row < 1)
+ return 0;
+
+ /* free unneeded rows */
+ i = 0;
+ if(slide > 0) {
+ /*
+ * slide screen to keep cursor where we expect it -
+ * tscrollup would work here, but we can optimize to
+ * memmove because we're freeing the earlier lines
+ */
+ for(/* i = 0 */; i < slide; i++) {
+ free(term.line[i]);
+ free(term.alt[i]);
+ }
+ memmove(term.line, term.line + slide, row * sizeof(Line));
+ memmove(term.alt, term.alt + slide, row * sizeof(Line));
+ }
+ for(i += row; i < term.row; i++) {
+ free(term.line[i]);
+ free(term.alt[i]);
+ }
+
+ /* resize to new height */
+ term.line = xrealloc(term.line, row * sizeof(Line));
+ term.alt = xrealloc(term.alt, row * sizeof(Line));
+ term.dirty = xrealloc(term.dirty, row * sizeof(*term.dirty));
+ term.tabs = xrealloc(term.tabs, col * sizeof(*term.tabs));
+
+ /* resize each row to new width, zero-pad if needed */
+ for(i = 0; i < minrow; i++) {
+ term.dirty[i] = 1;
+ term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph));
+ term.alt[i] = xrealloc(term.alt[i], col * sizeof(Glyph));
+ for(x = mincol; x < col; x++) {
+ term.line[i][x].state = 0;
+ term.alt[i][x].state = 0;
+ }
+ }
+
+ /* allocate any new rows */
+ for(/* i == minrow */; i < row; i++) {
+ term.dirty[i] = 1;
+ term.line[i] = xcalloc(col, sizeof(Glyph));
+ term.alt [i] = xcalloc(col, sizeof(Glyph));
+ }
+ if(col > term.col) {
+ bp = term.tabs + term.col;
+
+ memset(bp, 0, sizeof(*term.tabs) * (col - term.col));
+ while(--bp > term.tabs && !*bp)
+ /* nothing */ ;
+ for(bp += tabspaces; bp < term.tabs + col; bp += tabspaces)
+ *bp = 1;
+ }
+ /* update terminal size */
+ term.col = col;
+ term.row = row;
+ /* reset scrolling region */
+ tsetscroll(0, row-1);
+ /* make use of the LIMIT in tmoveto */
+ tmoveto(term.c.x, term.c.y);
+
+ return (slide > 0);
+}
+
+void
+xresize(int col, int row) {
+ xw.tw = MAX(1, col * xw.cw);
+ xw.th = MAX(1, row * xw.ch);
+
+ if(!usedbe) {
+ XFreePixmap(xw.dpy, xw.buf);
+ xw.buf = XCreatePixmap(xw.dpy, xw.win, xw.w, xw.h,
+ DefaultDepth(xw.dpy, xw.scr));
+ XSetForeground(xw.dpy, dc.gc, dc.col[IS_SET(MODE_REVERSE) ? defaultfg : defaultbg].pixel);
+ XFillRectangle(xw.dpy, xw.buf, dc.gc, 0, 0, xw.w, xw.h);
+ }
+
+ XftDrawChange(xw.draw, xw.buf);
+}
+
+void
+xloadcols(void) {
+ int i, r, g, b;
+ XRenderColor color = { .alpha = 0 };
+
+ /* load colors [0-15] colors and [256-LEN(colorname)[ (config.h) */
+ for(i = 0; i < LEN(colorname); i++) {
+ if(!colorname[i])
+ continue;
+ if(!XftColorAllocName(xw.dpy, xw.vis, xw.cmap, colorname[i], &dc.col[i])) {
+ die("Could not allocate color '%s'\n", colorname[i]);
+ }
+ }
+
+ /* load colors [16-255] ; same colors as xterm */
+ for(i = 16, r = 0; r < 6; r++) {
+ for(g = 0; g < 6; g++) {
+ for(b = 0; b < 6; b++) {
+ color.red = r == 0 ? 0 : 0x3737 + 0x2828 * r;
+ color.green = g == 0 ? 0 : 0x3737 + 0x2828 * g;
+ color.blue = b == 0 ? 0 : 0x3737 + 0x2828 * b;
+ if(!XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &color, &dc.col[i])) {
+ die("Could not allocate color %d\n", i);
+ }
+ i++;
+ }
+ }
+ }
+
+ for(r = 0; r < 24; r++, i++) {
+ color.red = color.green = color.blue = 0x0808 + 0x0a0a * r;
+ if(!XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &color,
+ &dc.col[i])) {
+ die("Could not allocate color %d\n", i);
+ }
+ }
+}
+
+void
+xtermclear(int col1, int row1, int col2, int row2) {
+ XftDrawRect(xw.draw,
+ &dc.col[IS_SET(MODE_REVERSE) ? defaultfg : defaultbg],
+ borderpx + col1 * xw.cw,
+ borderpx + row1 * xw.ch,
+ (col2-col1+1) * xw.cw,
+ (row2-row1+1) * xw.ch);
+}
+
+/*
+ * Absolute coordinates.
+ */
+void
+xclear(int x1, int y1, int x2, int y2) {
+ XftDrawRect(xw.draw,
+ &dc.col[IS_SET(MODE_REVERSE)? defaultfg : defaultbg],
+ x1, y1, x2-x1, y2-y1);
+}
+
+void
+xhints(void) {
+ XClassHint class = {opt_class ? opt_class : termname, termname};
+ XWMHints wm = {.flags = InputHint, .input = 1};
+ XSizeHints *sizeh = NULL;
+
+ sizeh = XAllocSizeHints();
+ if(xw.isfixed == False) {
+ sizeh->flags = PSize | PResizeInc | PBaseSize;
+ sizeh->height = xw.h;
+ sizeh->width = xw.w;
+ sizeh->height_inc = xw.ch;
+ sizeh->width_inc = xw.cw;
+ sizeh->base_height = 2 * borderpx;
+ sizeh->base_width = 2 * borderpx;
+ } else {
+ sizeh->flags = PMaxSize | PMinSize;
+ sizeh->min_width = sizeh->max_width = xw.fw;
+ sizeh->min_height = sizeh->max_height = xw.fh;
+ }
+
+ XSetWMProperties(xw.dpy, xw.win, NULL, NULL, NULL, 0, sizeh, &wm, &class);
+ XFree(sizeh);
+}
+
+int
+xloadfont(Font *f, FcPattern *pattern) {
+ FcPattern *match;
+ FcResult result;
+
+ match = FcFontMatch(NULL, pattern, &result);
+ if(!match)
+ return 1;
+
+ if(!(f->set = FcFontSort(0, match, FcTrue, 0, &result))) {
+ FcPatternDestroy(match);
+ return 1;
+ }
+
+ if(!(f->match = XftFontOpenPattern(xw.dpy, match))) {
+ FcPatternDestroy(match);
+ return 1;
+ }
+
+ f->pattern = FcPatternDuplicate(pattern);
+
+ f->ascent = f->match->ascent;
+ f->descent = f->match->descent;
+ f->lbearing = 0;
+ f->rbearing = f->match->max_advance_width;
+
+ f->height = f->match->height;
+ f->width = f->lbearing + f->rbearing;
+