st.c

   1 /* See LICENSE for licence details. */
   2 #define _XOPEN_SOURCE 600
   3 #include <ctype.h>
   4 #include <errno.h>
   5 #include <fcntl.h>
   6 #include <locale.h>
   7 #include <stdarg.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <signal.h>
  12 #include <sys/ioctl.h>
  13 #include <sys/select.h>
  14 #include <sys/stat.h>
  15 #include <sys/types.h>
  16 #include <sys/wait.h>
  17 #include <unistd.h>
  18 #include <X11/Xlib.h>
  19 #include <X11/keysym.h>
  20 #include <X11/Xutil.h>
  21
  22 #define TNAME "st"
  23
  24 /* Arbitrary sizes */
  25 #define ESCSIZ 256
  26 #define ESCARG 16
  27
  28 #define SERRNO strerror(errno)
  29 #define MIN(a, b)  ((a) < (b) ? (a) : (b))
  30 #define MAX(a, b)  ((a) < (b) ? (b) : (a))
  31 #define LEN(a)     (sizeof(a) / sizeof(a[0]))
  32 #define DEFAULT(a, b)     (a) = (a) ? (a) : (b)
  33 #define BETWEEN(x, a, b)  ((a) <= (x) && (x) <= (b))
  34 #define LIMIT(x, a, b)    (x) = (x) < (a) ? (a) : (x) > (b) ? (b) : (x)
  35
  36 /* Attribute, Cursor, Character state, Terminal mode, Screen draw mode */
  37 enum { ATnone=0 , ATreverse=1 , ATunderline=2, ATbold=4 };
  38 enum { CSup, CSdown, CSright, CSleft, CShide, CSdraw, CSwrap, CSsave, CSload };
  39 enum { CRset=1, CRupdate=2 };
  40 enum { TMwrap=1, TMinsert=2 };
  41 enum { SCupdate, SCredraw };
  42
  43 typedef int Color;
  44
  45 typedef struct {
  46         char c;     /* character code  */
  47         char mode;  /* attribute flags */
  48         Color fg;   /* foreground      */
  49         Color bg;   /* background      */
  50         char state; /* state flag      */
  51 } Glyph;
  52
  53 typedef Glyph* Line;
  54
  55 typedef struct {
  56         Glyph attr;  /* current char attributes */
  57         char hidden;
  58         int x;
  59         int y;
  60 } TCursor;
  61
  62 /* Escape sequence structs */
  63 /* ESC <pre> [[ [<priv>] <arg> [;]] <mode>] */
  64 typedef struct {
  65         char buf[ESCSIZ+1]; /* raw string */
  66         int len;            /* raw string length */
  67         char pre;
  68         char priv;
  69         int arg[ESCARG+1];
  70         int narg;           /* nb of args */
  71         char mode;
  72 } Escseq;
  73
  74 /* Internal representation of the screen */
  75 typedef struct {
  76         int row;    /* nb row */
  77         int col;    /* nb col */
  78         Line* line; /* screen */
  79         TCursor c;  /* cursor */
  80         int top;    /* top    scroll limit */
  81         int bot;    /* bottom scroll limit */
  82         int mode;   /* terminal mode */
  83 } Term;
  84
  85 /* Purely graphic info */
  86 typedef struct {
  87         Display* dis;
  88         Window win;
  89         int scr;
  90         int w;  /* window width  */
  91         int h;  /* window height */
  92         int ch; /* char height */
  93         int cw; /* char width  */
  94 } XWindow;
  95
  96 typedef struct {
  97         KeySym k;
  98         char s[ESCSIZ];
  99 } Key;
 100
 101 #include "config.h"
 102
 103 /* Drawing Context */
 104 typedef struct {
 105         unsigned long col[LEN(colorname)];
 106         XFontStruct* font;
 107         GC gc;
 108 } DC;
 109
 110 static void die(const char *errstr, ...);
 111 static void draw(int);
 112 static void execsh(void);
 113 static void sigchld(int);
 114 static void run(void);
 115
 116 static int escaddc(char);
 117 static int escfinal(char);
 118 static void escdump(void);
 119 static void eschandle(void);
 120 static void escparse(void);
 121 static void escreset(void);
 122
 123 static void tclearregion(int, int, int, int);
 124 static void tcpos(int);
 125 static void tcursor(int);
 126 static void tdeletechar(int);
 127 static void tdeleteline(int);
 128 static void tinsertblank(int);
 129 static void tinsertblankline(int);
 130 static void tmoveto(int, int);
 131 static void tnew(int, int);
 132 static void tnewline(void);
 133 static void tputc(char);
 134 static void tputs(char*, int);
 135 static void tresize(int, int);
 136 static void tscroll(void);
 137 static void tsetattr(int*, int);
 138 static void tsetchar(char);
 139 static void tsetscroll(int, int);
 140
 141 static void ttynew(void);
 142 static void ttyread(void);
 143 static void ttyresize(int, int);
 144 static void ttywrite(const char *, size_t);
 145
 146 static unsigned long xgetcol(const char *);
 147 static void xclear(int, int, int, int);
 148 static void xcursor(int);
 149 static void xdrawc(int, int, Glyph);
 150 static void xinit(void);
 151 static void xscroll(void);
 152
 153 static void expose(XEvent *);
 154 static char * kmap(KeySym);
 155 static void kpress(XEvent *);
 156 static void resize(XEvent *);
 157
 158 static void (*handler[LASTEvent])(XEvent *) = {
 159         [KeyPress] = kpress,
 160         [Expose] = expose,
 161         [ConfigureNotify] = resize
 162 };
 163
 164 /* Globals */
 165 static DC dc;
 166 static XWindow xw;
 167 static Term term;
 168 static Escseq escseq;
 169 static int cmdfd;
 170 static pid_t pid;
 171 static int running;
 172
 173 #ifdef DEBUG
 174 void
 175 tdump(void) {
 176         int row, col;
 177         Glyph c;
 178
 179         for(row = 0; row < term.row; row++) {
 180                 for(col = 0; col < term.col; col++) {
 181                         if(col == term.c.x && row == term.c.y)
 182                                 putchar('#');
 183                         else {
 184                                 c = term.line[row][col];
 185                                 putchar(c.state & CRset ? c.c : '.');
 186                         }
 187                 }
 188                 putchar('\n');
 189         }
 190 }
 191 #endif
 192
 193 void
 194 die(const char *errstr, ...) {
 195         va_list ap;
 196
 197         va_start(ap, errstr);
 198         vfprintf(stderr, errstr, ap);
 199         va_end(ap);
 200         exit(EXIT_FAILURE);
 201 }
 202
 203 void
 204 execsh(void) {
 205         char *args[3] = {SHELL, "-i", NULL};
 206         putenv("TERM=" TNAME);
 207         execvp(SHELL, args);
 208 }
 209
 210 void
 211 xbell(void) { /* visual bell */
 212         XRectangle r = { 0, 0, xw.w, xw.h };
 213         XSetForeground(xw.dis, dc.gc, dc.col[BellCol]);
 214         XFillRectangles(xw.dis, xw.win, dc.gc, &r, 1);
 215         /* usleep(30000); */
 216         draw(SCredraw);
 217 }
 218
 219 void
 220 sigchld(int a) {
 221         int stat = 0;
 222         if(waitpid(pid, &stat, 0) < 0)
 223                 die("Waiting for pid %hd failed: %s\n", pid, SERRNO);
 224         if(WIFEXITED(stat))
 225                 exit(WEXITSTATUS(stat));
 226         else
 227                 exit(EXIT_FAILURE);
 228 }
 229
 230 void
 231 ttynew(void) {
 232         int m, s;
 233         char *pts;
 234
 235         if((m = posix_openpt(O_RDWR | O_NOCTTY)) < 0)
 236                 die("openpt failed: %s\n", SERRNO);
 237         if(grantpt(m) < 0)
 238                 die("grandpt failed: %s\n", SERRNO);
 239         if(unlockpt(m) < 0)
 240                 die("unlockpt failed: %s\n", SERRNO);
 241         if(!(pts = ptsname(m)))
 242                 die("ptsname failed: %s\n", SERRNO);
 243         if((s = open(pts, O_RDWR | O_NOCTTY)) < 0)
 244                 die("Couldn't open slave: %s\n", SERRNO);
 245         fcntl(s, F_SETFL, O_NDELAY);
 246         switch(pid = fork()) {
 247         case -1:
 248                 die("fork failed\n");
 249                 break;
 250         case 0:
 251                 setsid(); /* create a new process group */
 252                 dup2(s, STDIN_FILENO);
 253                 dup2(s, STDOUT_FILENO);
 254                 dup2(s, STDERR_FILENO);
 255                 if(ioctl(s, TIOCSCTTY, NULL) < 0)
 256                         die("ioctl TTIOCSTTY failed: %s\n", SERRNO);
 257                 execsh();
 258                 break;
 259         default:
 260                 close(s);
 261                 cmdfd = m;
 262                 signal(SIGCHLD, sigchld);
 263         }
 264 }
 265
 266 void
 267 dump(char c) {
 268         static int col;
 269         fprintf(stderr, " %02x %c ", c, isprint(c)?c:'.');
 270         if(++col % 10 == 0)
 271                 fprintf(stderr, "\n");
 272 }
 273
 274 void
 275 ttyread(void) {
 276         char buf[BUFSIZ] = {0};
 277         int ret;
 278
 279         switch(ret = read(cmdfd, buf, BUFSIZ)) {
 280         case -1:
 281                 die("Couldn't read from shell: %s\n", SERRNO);
 282                 break;
 283         default:
 284                 tputs(buf, ret);
 285         }
 286 }
 287
 288 void
 289 ttywrite(const char *s, size_t n) {
 290         if(write(cmdfd, s, n) == -1)
 291                 die("write error on tty: %s\n", SERRNO);
 292 }
 293
 294 void
 295 ttyresize(int x, int y) {
 296         struct winsize w;
 297
 298         w.ws_row = term.row;
 299         w.ws_col = term.col;
 300         w.ws_xpixel = w.ws_ypixel = 0;
 301         if(ioctl(cmdfd, TIOCSWINSZ, &w) < 0)
 302                 fprintf(stderr, "Couldn't set window size: %s\n", SERRNO);
 303 }
 304
 305 int
 306 escfinal(char c) {
 307         if(escseq.len == 1)
 308                 switch(c) {
 309                 case '[':
 310                 case ']':
 311                 case '(':
 312                         return 0;
 313                 case '=':
 314                 case '>':
 315                 default:
 316                         return 1;
 317                 }
 318         else if(BETWEEN(c, 0x40, 0x7E))
 319                 return 1;
 320         return 0;
 321 }
 322
 323 void
 324 tcpos(int mode) {
 325         static int x = 0;
 326         static int y = 0;
 327
 328         if(mode == CSsave)
 329                 x = term.c.x, y = term.c.y;
 330         else if(mode == CSload)
 331                 tmoveto(x, y);
 332 }
 333
 334 void
 335 tnew(int col, int row) {   /* screen size */
 336         term.row = row, term.col = col;
 337         term.top = 0, term.bot = term.row - 1;
 338         /* mode */
 339         term.mode = TMwrap;
 340         /* cursor */
 341         term.c.attr.mode = ATnone;
 342         term.c.attr.fg = DefaultFG;
 343         term.c.attr.bg = DefaultBG;
 344         term.c.x = term.c.y = 0;
 345         term.c.hidden = 0;
 346         /* allocate screen */
 347         term.line = calloc(term.row, sizeof(Line));
 348         for(row = 0 ; row < term.row; row++)
 349                 term.line[row] = calloc(term.col, sizeof(Glyph));
 350 }
 351
 352 void
 353 tscroll(void) {
 354         Line temp = term.line[term.top];
 355         int i;
 356         /* X stuff _before_ the line swapping (results in wrong line index) */
 357         xscroll();
 358         for(i = term.top; i < term.bot; i++)
 359                 term.line[i] = term.line[i+1];
 360         memset(temp, 0, sizeof(Glyph) * term.col);
 361         term.line[term.bot] = temp;
 362 }
 363
 364 void
 365 tnewline(void) {
 366         int y = term.c.y + 1;
 367         if(y > term.bot)
 368                 tscroll(), y = term.bot;
 369         tmoveto(0, y);
 370 }
 371
 372 int
 373 escaddc(char c) {
 374         escseq.buf[escseq.len++] = c;
 375         if(escfinal(c) || escseq.len >= ESCSIZ) {
 376                 escparse(), eschandle();
 377                 return 0;
 378         }
 379         return 1;
 380 }
 381
 382 void
 383 escparse(void) {
 384         /* int noarg = 1; */
 385         char *p = escseq.buf;
 386
 387         escseq.narg = 0;
 388         switch(escseq.pre = *p++) {
 389         case '[': /* CSI */
 390                 if(*p == '?')
 391                         escseq.priv = 1, p++;
 392
 393                 while(p < escseq.buf+escseq.len) {
 394                         while(isdigit(*p)) {
 395                                 escseq.arg[escseq.narg] *= 10;
 396                                 escseq.arg[escseq.narg] += *(p++) - '0'/*, noarg = 0 */;
 397                         }
 398                         if(*p == ';')
 399                                 escseq.narg++, p++;
 400                         else {
 401                                 escseq.mode = *p;
 402                                 escseq.narg++;
 403                                 return;
 404                         }
 405                 }
 406                 break;
 407         case '(':
 408                 /* XXX: graphic character set */
 409                 break;
 410         }
 411 }
 412
 413 void
 414 tmoveto(int x, int y) {
 415         term.c.x = x < 0 ? 0 : x >= term.col ? term.col-1 : x;
 416         term.c.y = y < 0 ? 0 : y >= term.row ? term.row-1 : y;
 417 }
 418
 419 void
 420 tcursor(int dir) {
 421         int xf = term.c.x, yf = term.c.y;
 422
 423         switch(dir) {
 424         case CSup:
 425                 yf--;
 426                 break;
 427         case CSdown:
 428                 yf++;
 429                 break;
 430         case CSleft:
 431                 xf--;
 432                 if(xf < 0) {
 433                         xf = term.col-1, yf--;
 434                         if(yf < term.top)
 435                                 yf = term.top, xf = 0;
 436                 }
 437                 break;
 438         case CSright:
 439                 xf++;
 440                 if(xf >= term.col) {
 441                         xf = 0, yf++;
 442                         if(yf > term.bot)
 443                                 yf = term.bot, tscroll();
 444                 }
 445                 break;
 446         }
 447         tmoveto(xf, yf);
 448 }
 449
 450 void
 451 tsetchar(char c) {
 452         term.line[term.c.y][term.c.x] = term.c.attr;
 453         term.line[term.c.y][term.c.x].c = c;
 454         term.line[term.c.y][term.c.x].state |= CRset | CRupdate;
 455 }
 456
 457 void
 458 tclearregion(int x1, int y1, int x2, int y2) {
 459         int x, y;
 460
 461         LIMIT(x1, 0, term.col-1);
 462         LIMIT(x2, 0, term.col-1);
 463         LIMIT(y1, 0, term.row-1);
 464         LIMIT(y2, 0, term.row-1);
 465
 466         /* XXX: could be optimized */
 467         for(x = x1; x <= x2; x++)
 468                 for(y = y1; y <= y2; y++)
 469                         memset(&term.line[y][x], 0, sizeof(Glyph));
 470
 471         xclear(x1, y1, x2, y2);
 472 }
 473
 474 void
 475 tdeletechar(int n) {
 476         int src = term.c.x + n;
 477         int dst = term.c.x;
 478         int size = term.col - src;
 479
 480         if(src >= term.col) {
 481                 tclearregion(term.c.x, term.c.y, term.col-1, term.c.y);
 482                 return;
 483         }
 484         memmove(&term.line[term.c.y][dst], &term.line[term.c.y][src], size * sizeof(Glyph));
 485         tclearregion(term.col-size, term.c.y, term.col-1, term.c.y);
 486 }
 487
 488 void
 489 tinsertblank(int n) {
 490         int src = term.c.x;
 491         int dst = src + n;
 492         int size = term.col - n - src;
 493
 494         if(dst >= term.col) {
 495                 tclearregion(term.c.x, term.c.y, term.col-1, term.c.y);
 496                 return;
 497         }
 498         memmove(&term.line[term.c.y][dst], &term.line[term.c.y][src], size * sizeof(Glyph));
 499         tclearregion(src, term.c.y, dst, term.c.y);
 500 }
 501
 502 void
 503 tsetlinestate(int n, int state) {
 504         int i;
 505         for(i = 0; i < term.col; i++)
 506                 term.line[n][i].state |= state;
 507 }
 508
 509 void
 510 tinsertblankline (int n) {
 511         int i;
 512         Line blank;
 513         int bot = term.bot;
 514
 515         if(term.c.y > term.bot)
 516                 bot = term.row - 1;
 517         else if(term.c.y < term.top)
 518                 bot = term.top - 1;
 519         if(term.c.y + n >= bot) {
 520                 tclearregion(0, term.c.y, term.col-1, bot);
 521                 return;
 522         }
 523         for(i = bot; i >= term.c.y+n; i--) {
 524                 /* swap deleted line <-> blanked line */
 525                 blank = term.line[i];
 526                 term.line[i] = term.line[i-n];
 527                 term.line[i-n] = blank;
 528                 /* blank it */
 529                 memset(blank, 0, term.col * sizeof(Glyph));
 530                 tsetlinestate(i, CRupdate);
 531                 tsetlinestate(i-n, CRupdate);
 532         }
 533 }
 534
 535 void
 536 tdeleteline(int n) {
 537         int i;
 538         Line blank;
 539         int bot = term.bot;
 540
 541         if(term.c.y > term.bot)
 542                 bot = term.row - 1;
 543         else if(term.c.y < term.top)
 544                 bot = term.top - 1;
 545         if(term.c.y + n >= bot) {
 546                 tclearregion(0, term.c.y, term.col-1, bot);
 547                 return;
 548         }
 549         for(i = term.c.y; i <= bot-n; i++) {
 550                 /* swap deleted line <-> blanked line */
 551                 blank = term.line[i];
 552                 term.line[i] = term.line[i+n];
 553                 term.line[i+n] = blank;
 554                 /* blank it */
 555                 memset(blank, 0, term.col * sizeof(Glyph));
 556                 tsetlinestate(i, CRupdate);
 557                 tsetlinestate(i-n, CRupdate);
 558         }
 559 }
 560
 561 void
 562 tsetattr(int *attr, int l) {
 563         int i;
 564
 565         for(i = 0; i < l; i++) {
 566                 switch(attr[i]) {
 567                 case 0:
 568                         memset(&term.c.attr, 0, sizeof(term.c.attr));
 569                         term.c.attr.fg = DefaultFG;
 570                         term.c.attr.bg = DefaultBG;
 571                         break;
 572                 case 1:
 573                         term.c.attr.mode |= ATbold;
 574                         break;
 575                 case 4:
 576                         term.c.attr.mode |= ATunderline;
 577                         break;
 578                 case 7:
 579                         term.c.attr.mode |= ATreverse;
 580                         break;
 581                 case 8:
 582                         term.c.hidden = CShide;
 583                         break;
 584                 case 22:
 585                         term.c.attr.mode &= ~ATbold;
 586                         break;
 587                 case 24:
 588                         term.c.attr.mode &= ~ATunderline;
 589                         break;
 590                 case 27:
 591                         term.c.attr.mode &= ~ATreverse;
 592                         break;
 593                 case 39:
 594                         term.c.attr.fg = DefaultFG;
 595                         break;
 596                 case 49:
 597                         term.c.attr.fg = DefaultBG;
 598                         break;
 599                 default:
 600                         if(BETWEEN(attr[i], 30, 37))
 601                                 term.c.attr.fg = attr[i] - 30;
 602                         else if(BETWEEN(attr[i], 40, 47))
 603                                 term.c.attr.bg = attr[i] - 40;
 604                         break;
 605                 }
 606         }
 607 }
 608
 609 void
 610 tsetscroll(int t, int b) {
 611         int temp;
 612
 613         LIMIT(t, 0, term.row-1);
 614         LIMIT(b, 0, term.row-1);
 615         if(t > b) {
 616                 temp = t;
 617                 t = b;
 618                 b = temp;
 619         }
 620         term.top = t;
 621         term.bot = b;
 622 }
 623
 624 void
 625 eschandle(void) {
 626         switch(escseq.pre) {
 627         default:
 628                 goto unknown_seq;
 629         case '[':
 630                 switch(escseq.mode) {
 631                 default:
 632                 unknown_seq:
 633                         fprintf(stderr, "erresc: unknown sequence\n");
 634                         escdump();
 635                         break;
 636                 case '@': /* Insert <n> blank char */
 637                         DEFAULT(escseq.arg[0], 1);
 638                         tinsertblank(escseq.arg[0]);
 639                         break;
 640                 case 'A': /* Cursor <n> Up */
 641                 case 'e':
 642                         DEFAULT(escseq.arg[0], 1);
 643                         tmoveto(term.c.x, term.c.y-escseq.arg[0]);
 644                         break;
 645                 case 'B': /* Cursor <n> Down */
 646                         DEFAULT(escseq.arg[0], 1);
 647                         tmoveto(term.c.x, term.c.y+escseq.arg[0]);
 648                         break;
 649                 case 'C': /* Cursor <n> Forward */
 650                 case 'a':
 651                         DEFAULT(escseq.arg[0], 1);
 652                         tmoveto(term.c.x+escseq.arg[0], term.c.y);
 653                         break;
 654                 case 'D': /* Cursor <n> Backward */
 655                         DEFAULT(escseq.arg[0], 1);
 656                         tmoveto(term.c.x-escseq.arg[0], term.c.y);
 657                         break;
 658                 case 'E': /* Cursor <n> Down and first col */
 659                         DEFAULT(escseq.arg[0], 1);
 660                         tmoveto(0, term.c.y+escseq.arg[0]);
 661                         break;
 662                 case 'F': /* Cursor <n> Up and first col */
 663                         DEFAULT(escseq.arg[0], 1);
 664                         tmoveto(0, term.c.y-escseq.arg[0]);
 665                         break;
 666                 case 'G': /* Move to <col> */
 667                 case '`':
 668                         DEFAULT(escseq.arg[0], 1);
 669                         tmoveto(escseq.arg[0]-1, term.c.y);
 670                         break;
 671                 case 'H': /* Move to <row> <col> */
 672                 case 'f':
 673                         DEFAULT(escseq.arg[0], 1);
 674                         DEFAULT(escseq.arg[1], 1);
 675                         tmoveto(escseq.arg[1]-1, escseq.arg[0]-1);
 676                         break;
 677                 case 'J': /* Clear screen */
 678                         switch(escseq.arg[0]) {
 679                         case 0: /* below */
 680                                 tclearregion(term.c.x, term.c.y, term.col-1, term.row-1);
 681                                 break;
 682                         case 1: /* above */
 683                                 tclearregion(0, 0, term.c.x, term.c.y);
 684                                 break;
 685                         case 2: /* all */
 686                                 tclearregion(0, 0, term.col-1, term.row-1);
 687                                 break;
 688                         }
 689                         break;
 690                 case 'K': /* Clear line */
 691                         switch(escseq.arg[0]) {
 692                         case 0: /* right */
 693                                 tclearregion(term.c.x, term.c.y, term.col-1, term.c.y);
 694                                 break;
 695                         case 1: /* left */
 696                                 tclearregion(0, term.c.y, term.c.x, term.c.y);
 697                                 break;
 698                         case 2: /* all */
 699                                 tclearregion(0, term.c.y, term.col-1, term.c.y);
 700                                 break;
 701                         }
 702                         break;
 703                 case 'L': /* Insert <n> blank lines */
 704                         DEFAULT(escseq.arg[0], 1);
 705                         tinsertblankline(escseq.arg[0]);
 706                         break;
 707                 case 'l':
 708                         if(escseq.priv && escseq.arg[0] == 25)
 709                                 term.c.hidden = 1;
 710                         break;
 711                 case 'M': /* Delete <n> lines */
 712                         DEFAULT(escseq.arg[0], 1);
 713                         tdeleteline(escseq.arg[0]);
 714                         break;
 715                 case 'P': /* Delete <n> char */
 716                         DEFAULT(escseq.arg[0], 1);
 717                         tdeletechar(escseq.arg[0]);
 718                         break;
 719                 case 'd': /* Move to <row> */
 720                         DEFAULT(escseq.arg[0], 1);
 721                         tmoveto(term.c.x, escseq.arg[0]-1);
 722                         break;
 723                 case 'h': /* Set terminal mode */
 724                         if(escseq.priv && escseq.arg[0] == 25)
 725                                 term.c.hidden = 0;
 726                         break;
 727                 case 'm': /* Terminal attribute (color) */
 728                         tsetattr(escseq.arg, escseq.narg);
 729                         break;
 730                 case 'r':
 731                         if(escseq.priv)
 732                                 ;
 733                         else {
 734                                 DEFAULT(escseq.arg[0], 1);
 735                                 DEFAULT(escseq.arg[1], term.row);
 736                                 tsetscroll(escseq.arg[0]-1, escseq.arg[1]-1);
 737                         }
 738                         break;
 739                 case 's': /* Save cursor position */
 740                         tcpos(CSsave);
 741                         break;
 742                 case 'u': /* Load cursor position */
 743                         tcpos(CSload);
 744                         break;
 745                 }
 746                 break;
 747         }
 748 }
 749
 750 void
 751 escdump(void) {
 752         int i;
 753         printf("rawbuf  : %s\n", escseq.buf);
 754         printf("prechar : %c\n", escseq.pre);
 755         printf("private : %c\n", escseq.priv ? '?' : ' ');
 756         printf("narg    : %d\n", escseq.narg);
 757         if(escseq.narg)
 758                 for(i = 0; i < escseq.narg; i++)
 759                         printf("\targ %d = %d\n", i, escseq.arg[i]);
 760         printf("mode    : %c\n", escseq.mode);
 761 }
 762
 763 void
 764 escreset(void) {
 765         memset(&escseq, 0, sizeof(escseq));
 766 }
 767
 768 void
 769 tputtab(void) {
 770         int space = TAB - term.c.x % TAB;
 771
 772         if(term.c.x + space >= term.col)
 773                 space--;
 774
 775         for(; space > 0; space--)
 776                 tcursor(CSright);
 777 }
 778
 779 void
 780 tputc(char c) {
 781         static int inesc = 0;
 782 #if 0
 783         dump(c);
 784 #endif
 785         /* start of escseq */
 786         if(c == '\033')
 787                 escreset(), inesc = 1;
 788         else if(inesc) {
 789                 inesc = escaddc(c);
 790         } /* normal char */
 791         else switch(c) {
 792                 default:
 793                         tsetchar(c);
 794                         tcursor(CSright);
 795                         break;
 796                 case '\t':
 797                         tputtab();
 798                         break;
 799                 case '\b':
 800                         tcursor(CSleft);
 801                         break;
 802                 case '\r':
 803                         tmoveto(0, term.c.y);
 804                         break;
 805                 case '\n':
 806                         tnewline();
 807                         break;
 808                 case '\a':
 809                         xbell();
 810                         break;
 811         }
 812 }
 813
 814 void
 815 tputs(char *s, int len) {
 816         for(; len > 0; len--)
 817                 tputc(*s++);
 818 }
 819
 820 void
 821 tresize(int col, int row) {
 822         int i;
 823         Line *line;
 824         int minrow = MIN(row, term.row);
 825         int mincol = MIN(col, term.col);
 826
 827         if(col < 1 || row < 1)
 828                 return;
 829         /* alloc */
 830         line = calloc(row, sizeof(Line));
 831         for(i = 0 ; i < row; i++)
 832                 line[i] = calloc(col, sizeof(Glyph));
 833         /* copy */
 834         for(i = 0 ; i < minrow; i++)
 835                 memcpy(line[i], term.line[i], mincol * sizeof(Glyph));
 836         /* free */
 837         for(i = 0; i < term.row; i++)
 838                 free(term.line[i]);
 839         free(term.line);
 840
 841         LIMIT(term.c.x, 0, col-1);
 842         LIMIT(term.c.y, 0, row-1);
 843         LIMIT(term.top, 0, row-1);
 844         LIMIT(term.bot, 0, row-1);
 845
 846         term.bot = row-1;
 847         term.line = line;
 848         term.col = col, term.row = row;
 849 }
 850
 851 unsigned long
 852 xgetcol(const char *s) {
 853         XColor color;
 854         Colormap cmap = DefaultColormap(xw.dis, xw.scr);
 855
 856         if(!XAllocNamedColor(xw.dis, cmap, s, &color, &color)) {
 857                 color.pixel = WhitePixel(xw.dis, xw.scr);
 858                 fprintf(stderr, "Could not allocate color '%s'\n", s);
 859         }
 860         return color.pixel;
 861 }
 862
 863 void
 864 xclear(int x1, int y1, int x2, int y2) {
 865         XClearArea(xw.dis, xw.win,
 866                         x1 * xw.cw, y1 * xw.ch,
 867                         (x2-x1+1) * xw.cw, (y2-y1+1) * xw.ch,
 868                         False);
 869 }
 870
 871 void
 872 xscroll(void) {
 873         int srcy = (term.top+1) * xw.ch;
 874         int dsty = term.top * xw.ch;
 875         int height = (term.bot-term.top) * xw.ch;
 876
 877         xcursor(CShide);
 878         XCopyArea(xw.dis, xw.win, xw.win, dc.gc, 0, srcy, xw.w, height, 0, dsty);
 879         xclear(0, term.bot, term.col-1, term.bot);
 880 }
 881
 882 void
 883 xinit(void) {
 884         XGCValues values;
 885         unsigned long valuemask;
 886         XClassHint chint;
 887         XWMHints wmhint;
 888         XSizeHints shint;
 889         char *args[] = {NULL};
 890         int i;
 891
 892         xw.dis = XOpenDisplay(NULL);
 893         xw.scr = XDefaultScreen(xw.dis);
 894         if(!xw.dis)
 895                 die("Can't open display\n");
 896
 897         /* font */
 898         if(!(dc.font = XLoadQueryFont(xw.dis, FONT)))
 899                 die("Can't load font %s\n", FONT);
 900
 901         xw.cw = dc.font->max_bounds.rbearing - dc.font->min_bounds.lbearing;
 902         xw.ch = dc.font->ascent + dc.font->descent + LINESPACE;
 903
 904         /* colors */
 905         for(i = 0; i < LEN(colorname); i++)
 906                 dc.col[i] = xgetcol(colorname[i]);
 907
 908         term.c.attr.fg = DefaultFG;
 909         term.c.attr.bg = DefaultBG;
 910         term.c.attr.mode = ATnone;
 911         /* windows */
 912         xw.h = term.row * xw.ch;
 913         xw.w = term.col * xw.cw;
 914         /* XXX: this BORDER is useless after the first resize, handle it in xdraws() */
 915         xw.win = XCreateSimpleWindow(xw.dis, XRootWindow(xw.dis, xw.scr), 0, 0,
 916                         xw.w, xw.h, BORDER,
 917                         dc.col[DefaultBG],
 918                         dc.col[DefaultBG]);
 919         /* gc */
 920         values.foreground = XWhitePixel(xw.dis, xw.scr);
 921         values.font = dc.font->fid;
 922         valuemask = GCForeground | GCFont;
 923         dc.gc = XCreateGC(xw.dis, xw.win, valuemask, &values);
 924         XMapWindow(xw.dis, xw.win);
 925         /* wm stuff */
 926         chint.res_name = TNAME, chint.res_class = TNAME;
 927         wmhint.input = 1, wmhint.flags = InputHint;
 928         shint.height_inc = xw.ch, shint.width_inc = xw.cw;
 929         shint.height = xw.h, shint.width = xw.w;
 930         shint.flags = PSize | PResizeInc;
 931         XSetWMProperties(xw.dis, xw.win, NULL, NULL, &args[0], 0, &shint, &wmhint, &chint);
 932         XStoreName(xw.dis, xw.win, TNAME);
 933         XSync(xw.dis, 0);
 934 }
 935
 936 void
 937 xdrawc(int x, int y, Glyph g) {
 938         XRectangle r = { x * xw.cw, y * xw.ch, xw.cw, xw.ch };
 939         unsigned long xfg, xbg;
 940
 941         /* reverse video */
 942         if(g.mode & ATreverse)
 943                 xfg = dc.col[g.bg], xbg = dc.col[g.fg];
 944         else
 945                 xfg = dc.col[g.fg], xbg = dc.col[g.bg];
 946         /* background */
 947         XSetForeground(xw.dis, dc.gc, xbg);
 948         XFillRectangles(xw.dis, xw.win, dc.gc, &r, 1);
 949         /* string */
 950         XSetForeground(xw.dis, dc.gc, xfg);
 951         XDrawString(xw.dis, xw.win, dc.gc, r.x, r.y+dc.font->ascent, &(g.c), 1);
 952         if(g.mode & ATbold)      /* XXX: bold hack (draw again at x+1) */
 953                 XDrawString(xw.dis, xw.win, dc.gc, r.x+1, r.y+dc.font->ascent, &(g.c), 1);
 954         /* underline */
 955         if(g.mode & ATunderline) {
 956                 r.y += dc.font->ascent + 1;
 957                 XDrawLine(xw.dis, xw.win, dc.gc, r.x, r.y, r.x+r.width-1, r.y);
 958         }
 959 }
 960
 961 void
 962 xcursor(int mode) {
 963         static int oldx = 0;
 964         static int oldy = 0;
 965         Glyph g = {' ', ATnone, DefaultBG, DefaultCS, 0};
 966
 967         LIMIT(oldx, 0, term.col-1);
 968         LIMIT(oldy, 0, term.row-1);
 969
 970         if(term.line[term.c.y][term.c.x].state & CRset)
 971                 g.c = term.line[term.c.y][term.c.x].c;
 972         /* remove the old cursor */
 973         if(term.line[oldy][oldx].state & CRset)
 974                 xdrawc(oldx, oldy, term.line[oldy][oldx]);
 975         else
 976                 xclear(oldx, oldy, oldx, oldy);
 977         /* draw the new one */
 978         if(mode == CSdraw) {
 979                 xdrawc(term.c.x, term.c.y, g);
 980                 oldx = term.c.x, oldy = term.c.y;
 981         }
 982 }
 983
 984 void
 985 draw(int redraw_all) {
 986         int x, y;
 987         int changed, set;
 988
 989         if(redraw_all)
 990                 XClearWindow(xw.dis, xw.win);
 991
 992         /* XXX: drawing could be optimised */
 993         for(y = 0; y < term.row; y++) {
 994                 for(x = 0; x < term.col; x++) {
 995                         changed = term.line[y][x].state & CRupdate;
 996                         set = term.line[y][x].state & CRset;
 997                         if(redraw_all || changed) {
 998                                 term.line[y][x].state &= ~CRupdate;
 999                                 if(set)
1000                                         xdrawc(x, y, term.line[y][x]);
1001                                 else
1002                                         xclear(x, y, x, y);
1003                         }
1004                 }
1005         }
1006         xcursor(CSdraw);
1007 }
1008
1009 void
1010 expose(XEvent *ev) {
1011         draw(SCredraw);
1012 }
1013
1014 char *
1015 kmap(KeySym k) {
1016         int i;
1017         for(i = 0; i < LEN(key); i++)
1018                 if(key[i].k == k)
1019                         return (char*)key[i].s;
1020         return NULL;
1021 }
1022
1023 void
1024 kpress(XEvent *ev) {
1025         XKeyEvent *e = &ev->xkey;
1026         KeySym ksym;
1027         char buf[32];
1028         char *customkey;
1029         int len;
1030         int meta;
1031         int shift;
1032
1033         meta  = e->state & Mod1Mask;
1034         shift = e->state & ShiftMask;
1035         len = XLookupString(e, buf, sizeof(buf), &ksym, NULL);
1036
1037         if(customkey = kmap(ksym))
1038                 ttywrite(customkey, strlen(customkey));
1039         else if(len > 0) {
1040                 buf[sizeof(buf)-1] = '\0';
1041                 if(meta && len == 1)
1042                         ttywrite("\033", 1);
1043                 ttywrite(buf, len);
1044         } else
1045                 switch(ksym) {
1046                 case XK_Insert:
1047                         if(shift)
1048                                 /* XXX: paste X clipboard */;
1049                         break;
1050                 default:
1051                         fprintf(stderr, "errkey: %d\n", (int)ksym);
1052                         break;
1053                 }
1054 }
1055
1056 void
1057 resize(XEvent *e) {
1058         int col, row;
1059         col = e->xconfigure.width / xw.cw;
1060         row = e->xconfigure.height / xw.ch;
1061
1062         if(term.col != col || term.row != row) {
1063                 tresize(col, row);
1064                 ttyresize(col, row);
1065                 xw.w = e->xconfigure.width;
1066                 xw.h = e->xconfigure.height;
1067                 draw(SCredraw);
1068         }
1069 }
1070
1071 void
1072 run(void) {
1073         XEvent ev;
1074         fd_set rfd;
1075         int xfd = XConnectionNumber(xw.dis);
1076
1077         running = 1;
1078         XSelectInput(xw.dis, xw.win, ExposureMask | KeyPressMask | StructureNotifyMask);
1079         XResizeWindow(xw.dis, xw.win, xw.w , xw.h); /* fix resize bug in wmii (?) */
1080
1081         while(running) {
1082                 FD_ZERO(&rfd);
1083                 FD_SET(cmdfd, &rfd);
1084                 FD_SET(xfd, &rfd);
1085                 if(select(MAX(xfd, cmdfd)+1, &rfd, NULL, NULL, NULL) == -1) {
1086                         if(errno == EINTR)
1087                                 continue;
1088                         die("select failed: %s\n", SERRNO);
1089                 }
1090                 if(FD_ISSET(cmdfd, &rfd)) {
1091                         ttyread();
1092                         draw(SCupdate);
1093                 }
1094                 while(XPending(xw.dis)) {
1095                         XNextEvent(xw.dis, &ev);
1096                         if(handler[ev.type])
1097                                 (handler[ev.type])(&ev);
1098                 }
1099         }
1100 }
1101
1102 int
1103 main(int argc, char *argv[]) {
1104         if(argc == 2 && !strncmp("-v", argv[1], 3))
1105                 die("st-" VERSION ", © 2009 st engineers\n");
1106         else if(argc != 1)
1107                 die("usage: st [-v]\n");
1108         setlocale(LC_CTYPE, "");
1109         tnew(80, 24);
1110         ttynew();
1111         xinit();
1112         run();
1113         return 0;
1114 }