x.c (49038B)
1 /* See LICENSE for license details. */ 2 #include <errno.h> 3 #include <math.h> 4 #include <limits.h> 5 #include <locale.h> 6 #include <signal.h> 7 #include <sys/select.h> 8 #include <time.h> 9 #include <unistd.h> 10 #include <libgen.h> 11 #include <X11/Xatom.h> 12 #include <X11/Xlib.h> 13 /* #include <X11/cursorfont.h> */ 14 #include <X11/keysym.h> 15 #include <X11/Xft/Xft.h> 16 #include <X11/XKBlib.h> 17 #include <X11/Xcursor/Xcursor.h> 18 19 char *argv0; 20 #include "arg.h" 21 #include "st.h" 22 #include "win.h" 23 24 /* types used in config.h */ 25 typedef struct { 26 uint mod; 27 KeySym keysym; 28 void (*func)(const Arg *); 29 const Arg arg; 30 } Shortcut; 31 32 typedef struct { 33 uint mod; 34 uint button; 35 void (*func)(const Arg *); 36 const Arg arg; 37 uint release; 38 int altscrn; /* 0: don't care, -1: not alt screen, 1: alt screen */ 39 } MouseShortcut; 40 41 typedef struct { 42 KeySym k; 43 uint mask; 44 char *s; 45 /* three-valued logic variables: 0 indifferent, 1 on, -1 off */ 46 signed char appkey; /* application keypad */ 47 signed char appcursor; /* application cursor */ 48 } Key; 49 50 /* X modifiers */ 51 #define XK_ANY_MOD UINT_MAX 52 #define XK_NO_MOD 0 53 #define XK_SWITCH_MOD (1<<13|1<<14) 54 55 /* function definitions used in config.h */ 56 static void clipcopy(const Arg *); 57 static void clippaste(const Arg *); 58 static void numlock(const Arg *); 59 static void selpaste(const Arg *); 60 static void zoom(const Arg *); 61 static void zoomabs(const Arg *); 62 static void zoomreset(const Arg *); 63 static void ttysend(const Arg *); 64 static void togglebigfont(const Arg *); 65 66 /* config.h for applying patches and the configuration. */ 67 #include "config.h" 68 69 /* XEMBED messages */ 70 #define XEMBED_FOCUS_IN 4 71 #define XEMBED_FOCUS_OUT 5 72 73 /* macros */ 74 #define IS_SET(flag) ((win.mode & (flag)) != 0) 75 #define TRUERED(x) (((x) & 0xff0000) >> 8) 76 #define TRUEGREEN(x) (((x) & 0xff00)) 77 #define TRUEBLUE(x) (((x) & 0xff) << 8) 78 79 typedef XftDraw *Draw; 80 typedef XftColor Color; 81 typedef XftGlyphFontSpec GlyphFontSpec; 82 83 /* Purely graphic info */ 84 typedef struct { 85 int tw, th; /* tty width and height */ 86 int w, h; /* window width and height */ 87 int hborderpx, vborderpx; 88 int ch; /* char height */ 89 int cw; /* char width */ 90 int mode; /* window state/mode flags */ 91 int cursor; /* cursor style */ 92 } TermWindow; 93 94 typedef struct { 95 Display *dpy; 96 Colormap cmap; 97 Window win; 98 Drawable buf; 99 GlyphFontSpec *specbuf; /* font spec buffer used for rendering */ 100 Atom xembed, wmdeletewin, netwmname, netwmiconname, netwmpid; 101 struct { 102 XIM xim; 103 XIC xic; 104 XPoint spot; 105 XVaNestedList spotlist; 106 } ime; 107 Draw draw; 108 Visual *vis; 109 XSetWindowAttributes attrs; 110 int scr; 111 int isfixed; /* is fixed geometry? */ 112 int l, t; /* left and top offset */ 113 int gm; /* geometry mask */ 114 } XWindow; 115 116 typedef struct { 117 Atom xtarget; 118 char *primary, *clipboard; 119 struct timespec tclick1; 120 struct timespec tclick2; 121 } XSelection; 122 123 /* Font structure */ 124 #define Font Font_ 125 typedef struct { 126 int height; 127 int width; 128 int ascent; 129 int descent; 130 int badslant; 131 int badweight; 132 short lbearing; 133 short rbearing; 134 XftFont *match; 135 FcFontSet *set; 136 FcPattern *pattern; 137 } Font; 138 139 /* Drawing Context */ 140 typedef struct { 141 Color *col; 142 size_t collen; 143 Font font, bfont, ifont, ibfont; 144 GC gc; 145 } DC; 146 147 static inline ushort sixd_to_16bit(int); 148 static int xmakeglyphfontspecs(XftGlyphFontSpec *, const Glyph *, int, int, int); 149 static void xdrawglyphfontspecs(const XftGlyphFontSpec *, Glyph, int, int, int, int); 150 static void xdrawglyph(Glyph, int, int); 151 static void xclear(int, int, int, int); 152 static int xgeommasktogravity(int); 153 static int ximopen(Display *); 154 static void ximinstantiate(Display *, XPointer, XPointer); 155 static void ximdestroy(XIM, XPointer, XPointer); 156 static int xicdestroy(XIC, XPointer, XPointer); 157 static void xinit(int, int); 158 static void cresize(int, int); 159 static void xresize(int, int); 160 static void xhints(void); 161 static int xloadcolor(int, const char *, Color *); 162 static int xloadfont(Font *, FcPattern *); 163 static void xloadfonts(const char *, double); 164 static void xreloadfont(); 165 static void xunloadfont(Font *); 166 static void xunloadfonts(void); 167 static void xsetenv(void); 168 static void xseturgency(int); 169 static int evcol(XEvent *); 170 static int evrow(XEvent *); 171 172 static void expose(XEvent *); 173 static void visibility(XEvent *); 174 static void unmap(XEvent *); 175 static void kpress(XEvent *); 176 static void cmessage(XEvent *); 177 static void resize(XEvent *); 178 static void focus(XEvent *); 179 static uint buttonmask(uint); 180 static int mouseaction(XEvent *, uint); 181 static void brelease(XEvent *); 182 static void bpress(XEvent *); 183 static void bmotion(XEvent *); 184 static void propnotify(XEvent *); 185 static void selnotify(XEvent *); 186 static void selclear_(XEvent *); 187 static void selrequest(XEvent *); 188 static void setsel(char *, Time); 189 static void mousesel(XEvent *, int); 190 static void mousereport(XEvent *); 191 static char *kmap(KeySym, uint); 192 static int match(uint, uint); 193 194 static void run(void); 195 static void usage(void); 196 197 static void (*handler[LASTEvent])(XEvent *) = { 198 [KeyPress] = kpress, 199 [ClientMessage] = cmessage, 200 [ConfigureNotify] = resize, 201 [VisibilityNotify] = visibility, 202 [UnmapNotify] = unmap, 203 [Expose] = expose, 204 [FocusIn] = focus, 205 [FocusOut] = focus, 206 [MotionNotify] = bmotion, 207 [ButtonPress] = bpress, 208 [ButtonRelease] = brelease, 209 /* 210 * Uncomment if you want the selection to disappear when you select something 211 * different in another window. 212 */ 213 /* [SelectionClear] = selclear_, */ 214 [SelectionNotify] = selnotify, 215 /* 216 * PropertyNotify is only turned on when there is some INCR transfer happening 217 * for the selection retrieval. 218 */ 219 [PropertyNotify] = propnotify, 220 [SelectionRequest] = selrequest, 221 }; 222 223 /* Globals */ 224 static DC dc; 225 static XWindow xw; 226 static XSelection xsel; 227 static TermWindow win; 228 229 /* Font Ring Cache */ 230 enum { 231 FRC_NORMAL, 232 FRC_ITALIC, 233 FRC_BOLD, 234 FRC_ITALICBOLD 235 }; 236 237 typedef struct { 238 XftFont *font; 239 int flags; 240 Rune unicodep; 241 } Fontcache; 242 243 /* Fontcache is an array now. A new font will be appended to the array. */ 244 static Fontcache *frc = NULL; 245 static int frclen = 0; 246 static int frccap = 0; 247 static char *usedfont = NULL; 248 static double usedfontsize = 0; 249 static double defaultfontsize = 0; 250 251 static char *opt_class = NULL; 252 static char **opt_cmd = NULL; 253 static char *opt_embed = NULL; 254 static char *opt_font = NULL; 255 static char *opt_io = NULL; 256 static char *opt_line = NULL; 257 static char *opt_name = NULL; 258 static char *opt_title = NULL; 259 260 static uint buttons; /* bit field of pressed buttons */ 261 262 void 263 clipcopy(const Arg *dummy) 264 { 265 Atom clipboard; 266 267 free(xsel.clipboard); 268 xsel.clipboard = NULL; 269 270 if (xsel.primary != NULL) { 271 xsel.clipboard = xstrdup(xsel.primary); 272 clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0); 273 XSetSelectionOwner(xw.dpy, clipboard, xw.win, CurrentTime); 274 } 275 } 276 277 void 278 clippaste(const Arg *dummy) 279 { 280 Atom clipboard; 281 282 clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0); 283 XConvertSelection(xw.dpy, clipboard, xsel.xtarget, clipboard, 284 xw.win, CurrentTime); 285 } 286 287 void 288 selpaste(const Arg *dummy) 289 { 290 XConvertSelection(xw.dpy, XA_PRIMARY, xsel.xtarget, XA_PRIMARY, 291 xw.win, CurrentTime); 292 } 293 294 void 295 numlock(const Arg *dummy) 296 { 297 win.mode ^= MODE_NUMLOCK; 298 } 299 300 void 301 zoom(const Arg *arg) 302 { 303 Arg larg; 304 305 larg.f = usedfontsize + arg->f; 306 zoomabs(&larg); 307 } 308 309 void 310 zoomabs(const Arg *arg) 311 { 312 xunloadfonts(); 313 xloadfonts(usedfont, arg->f); 314 cresize(0, 0); 315 redraw(); 316 xhints(); 317 } 318 319 void 320 zoomreset(const Arg *arg) 321 { 322 Arg larg; 323 324 if (defaultfontsize > 0) { 325 larg.f = defaultfontsize; 326 zoomabs(&larg); 327 } 328 } 329 330 void 331 ttysend(const Arg *arg) 332 { 333 ttywrite(arg->s, strlen(arg->s), 1); 334 } 335 336 void 337 togglebigfont(const Arg *dummy) 338 { 339 curfont = curfont ? 0 : 1; 340 xunloadfonts(); 341 xloadfonts(fonts[curfont], 0); 342 cresize(0, 0); 343 redraw(); 344 xhints(); 345 } 346 347 int 348 evcol(XEvent *e) 349 { 350 int x = e->xbutton.x - win.hborderpx; 351 LIMIT(x, 0, win.tw - 1); 352 return x / win.cw; 353 } 354 355 int 356 evrow(XEvent *e) 357 { 358 int y = e->xbutton.y - win.vborderpx; 359 LIMIT(y, 0, win.th - 1); 360 return y / win.ch; 361 } 362 363 void 364 mousesel(XEvent *e, int done) 365 { 366 int type, seltype = SEL_REGULAR; 367 uint state = e->xbutton.state & ~(Button1Mask | forcemousemod); 368 369 for (type = 1; type < LEN(selmasks); ++type) { 370 if (match(selmasks[type], state)) { 371 seltype = type; 372 break; 373 } 374 } 375 selextend(evcol(e), evrow(e), seltype, done); 376 if (done) 377 setsel(getsel(), e->xbutton.time); 378 } 379 380 void 381 mousereport(XEvent *e) 382 { 383 int len, btn, code; 384 int x = evcol(e), y = evrow(e); 385 int state = e->xbutton.state; 386 char buf[40]; 387 static int ox, oy; 388 389 if (e->type == MotionNotify) { 390 if (x == ox && y == oy) 391 return; 392 if (!IS_SET(MODE_MOUSEMOTION) && !IS_SET(MODE_MOUSEMANY)) 393 return; 394 /* MODE_MOUSEMOTION: no reporting if no button is pressed */ 395 if (IS_SET(MODE_MOUSEMOTION) && buttons == 0) 396 return; 397 /* Set btn to lowest-numbered pressed button, or 12 if no 398 * buttons are pressed. */ 399 for (btn = 1; btn <= 11 && !(buttons & (1<<(btn-1))); btn++) 400 ; 401 code = 32; 402 } else { 403 btn = e->xbutton.button; 404 /* Only buttons 1 through 11 can be encoded */ 405 if (btn < 1 || btn > 11) 406 return; 407 if (e->type == ButtonRelease) { 408 /* MODE_MOUSEX10: no button release reporting */ 409 if (IS_SET(MODE_MOUSEX10)) 410 return; 411 /* Don't send release events for the scroll wheel */ 412 if (btn == 4 || btn == 5) 413 return; 414 } 415 code = 0; 416 } 417 418 ox = x; 419 oy = y; 420 421 /* Encode btn into code. If no button is pressed for a motion event in 422 * MODE_MOUSEMANY, then encode it as a release. */ 423 if ((!IS_SET(MODE_MOUSESGR) && e->type == ButtonRelease) || btn == 12) 424 code += 3; 425 else if (btn >= 8) 426 code += 128 + btn - 8; 427 else if (btn >= 4) 428 code += 64 + btn - 4; 429 else 430 code += btn - 1; 431 432 if (!IS_SET(MODE_MOUSEX10)) { 433 code += ((state & ShiftMask ) ? 4 : 0) 434 + ((state & Mod1Mask ) ? 8 : 0) /* meta key: alt */ 435 + ((state & ControlMask) ? 16 : 0); 436 } 437 438 if (IS_SET(MODE_MOUSESGR)) { 439 len = snprintf(buf, sizeof(buf), "\033[<%d;%d;%d%c", 440 code, x+1, y+1, 441 e->type == ButtonRelease ? 'm' : 'M'); 442 } else if (x < 223 && y < 223) { 443 len = snprintf(buf, sizeof(buf), "\033[M%c%c%c", 444 32+code, 32+x+1, 32+y+1); 445 } else { 446 return; 447 } 448 449 ttywrite(buf, len, 0); 450 } 451 452 uint 453 buttonmask(uint button) 454 { 455 return button == Button1 ? Button1Mask 456 : button == Button2 ? Button2Mask 457 : button == Button3 ? Button3Mask 458 : button == Button4 ? Button4Mask 459 : button == Button5 ? Button5Mask 460 : 0; 461 } 462 463 int 464 mouseaction(XEvent *e, uint release) 465 { 466 MouseShortcut *ms; 467 468 /* ignore Button<N>mask for Button<N> - it's set on release */ 469 uint state = e->xbutton.state & ~buttonmask(e->xbutton.button); 470 471 for (ms = mshortcuts; ms < mshortcuts + LEN(mshortcuts); ms++) { 472 if (ms->release == release && 473 ms->button == e->xbutton.button && 474 (!ms->altscrn || (ms->altscrn == (tisaltscr() ? 1 : -1))) && 475 (match(ms->mod, state) || /* exact or forced */ 476 match(ms->mod, state & ~forcemousemod))) { 477 ms->func(&(ms->arg)); 478 return 1; 479 } 480 } 481 482 return 0; 483 } 484 485 void 486 bpress(XEvent *e) 487 { 488 int btn = e->xbutton.button; 489 struct timespec now; 490 int snap; 491 492 if (1 <= btn && btn <= 11) 493 buttons |= 1 << (btn-1); 494 495 if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) { 496 mousereport(e); 497 return; 498 } 499 500 if (mouseaction(e, 0)) 501 return; 502 503 if (btn == Button1) { 504 /* 505 * If the user clicks below predefined timeouts specific 506 * snapping behaviour is exposed. 507 */ 508 clock_gettime(CLOCK_MONOTONIC, &now); 509 if (TIMEDIFF(now, xsel.tclick2) <= tripleclicktimeout) { 510 snap = SNAP_LINE; 511 } else if (TIMEDIFF(now, xsel.tclick1) <= doubleclicktimeout) { 512 snap = SNAP_WORD; 513 } else { 514 snap = 0; 515 } 516 xsel.tclick2 = xsel.tclick1; 517 xsel.tclick1 = now; 518 519 selstart(evcol(e), evrow(e), snap); 520 } 521 } 522 523 void 524 propnotify(XEvent *e) 525 { 526 XPropertyEvent *xpev; 527 Atom clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0); 528 529 xpev = &e->xproperty; 530 if (xpev->state == PropertyNewValue && 531 (xpev->atom == XA_PRIMARY || 532 xpev->atom == clipboard)) { 533 selnotify(e); 534 } 535 } 536 537 void 538 selnotify(XEvent *e) 539 { 540 ulong nitems, ofs, rem; 541 int format; 542 uchar *data, *last, *repl; 543 Atom type, incratom, property = None; 544 545 incratom = XInternAtom(xw.dpy, "INCR", 0); 546 547 ofs = 0; 548 if (e->type == SelectionNotify) 549 property = e->xselection.property; 550 else if (e->type == PropertyNotify) 551 property = e->xproperty.atom; 552 553 if (property == None) 554 return; 555 556 do { 557 if (XGetWindowProperty(xw.dpy, xw.win, property, ofs, 558 BUFSIZ/4, False, AnyPropertyType, 559 &type, &format, &nitems, &rem, 560 &data)) { 561 fprintf(stderr, "Clipboard allocation failed\n"); 562 return; 563 } 564 565 if (e->type == PropertyNotify && nitems == 0 && rem == 0) { 566 /* 567 * If there is some PropertyNotify with no data, then 568 * this is the signal of the selection owner that all 569 * data has been transferred. We won't need to receive 570 * PropertyNotify events anymore. 571 */ 572 MODBIT(xw.attrs.event_mask, 0, PropertyChangeMask); 573 XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, 574 &xw.attrs); 575 } 576 577 if (type == incratom) { 578 /* 579 * Activate the PropertyNotify events so we receive 580 * when the selection owner does send us the next 581 * chunk of data. 582 */ 583 MODBIT(xw.attrs.event_mask, 1, PropertyChangeMask); 584 XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, 585 &xw.attrs); 586 587 /* 588 * Deleting the property is the transfer start signal. 589 */ 590 XDeleteProperty(xw.dpy, xw.win, (int)property); 591 continue; 592 } 593 594 /* 595 * As seen in getsel: 596 * Line endings are inconsistent in the terminal and GUI world 597 * copy and pasting. When receiving some selection data, 598 * replace all '\n' with '\r'. 599 * FIXME: Fix the computer world. 600 */ 601 repl = data; 602 last = data + nitems * format / 8; 603 while ((repl = memchr(repl, '\n', last - repl))) { 604 *repl++ = '\r'; 605 } 606 607 if (IS_SET(MODE_BRCKTPASTE) && ofs == 0) 608 ttywrite("\033[200~", 6, 0); 609 ttywrite((char *)data, nitems * format / 8, 1); 610 if (IS_SET(MODE_BRCKTPASTE) && rem == 0) 611 ttywrite("\033[201~", 6, 0); 612 XFree(data); 613 /* number of 32-bit chunks returned */ 614 ofs += nitems * format / 32; 615 } while (rem > 0); 616 617 /* 618 * Deleting the property again tells the selection owner to send the 619 * next data chunk in the property. 620 */ 621 XDeleteProperty(xw.dpy, xw.win, (int)property); 622 } 623 624 void 625 xclipcopy(void) 626 { 627 clipcopy(NULL); 628 } 629 630 void 631 selclear_(XEvent *e) 632 { 633 selclear(); 634 } 635 636 void 637 selrequest(XEvent *e) 638 { 639 XSelectionRequestEvent *xsre; 640 XSelectionEvent xev; 641 Atom xa_targets, string, clipboard; 642 char *seltext; 643 644 xsre = (XSelectionRequestEvent *) e; 645 xev.type = SelectionNotify; 646 xev.requestor = xsre->requestor; 647 xev.selection = xsre->selection; 648 xev.target = xsre->target; 649 xev.time = xsre->time; 650 if (xsre->property == None) 651 xsre->property = xsre->target; 652 653 /* reject */ 654 xev.property = None; 655 656 xa_targets = XInternAtom(xw.dpy, "TARGETS", 0); 657 if (xsre->target == xa_targets) { 658 /* respond with the supported type */ 659 string = xsel.xtarget; 660 XChangeProperty(xsre->display, xsre->requestor, xsre->property, 661 XA_ATOM, 32, PropModeReplace, 662 (uchar *) &string, 1); 663 xev.property = xsre->property; 664 } else if (xsre->target == xsel.xtarget || xsre->target == XA_STRING) { 665 /* 666 * xith XA_STRING non ascii characters may be incorrect in the 667 * requestor. It is not our problem, use utf8. 668 */ 669 clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0); 670 if (xsre->selection == XA_PRIMARY) { 671 seltext = xsel.primary; 672 } else if (xsre->selection == clipboard) { 673 seltext = xsel.clipboard; 674 } else { 675 fprintf(stderr, 676 "Unhandled clipboard selection 0x%lx\n", 677 xsre->selection); 678 return; 679 } 680 if (seltext != NULL) { 681 XChangeProperty(xsre->display, xsre->requestor, 682 xsre->property, xsre->target, 683 8, PropModeReplace, 684 (uchar *)seltext, strlen(seltext)); 685 xev.property = xsre->property; 686 } 687 } 688 689 /* all done, send a notification to the listener */ 690 if (!XSendEvent(xsre->display, xsre->requestor, 1, 0, (XEvent *) &xev)) 691 fprintf(stderr, "Error sending SelectionNotify event\n"); 692 } 693 694 void 695 setsel(char *str, Time t) 696 { 697 if (!str) 698 return; 699 700 free(xsel.primary); 701 xsel.primary = str; 702 703 XSetSelectionOwner(xw.dpy, XA_PRIMARY, xw.win, t); 704 if (XGetSelectionOwner(xw.dpy, XA_PRIMARY) != xw.win) 705 selclear(); 706 } 707 708 void 709 xsetsel(char *str) 710 { 711 setsel(str, CurrentTime); 712 } 713 714 void 715 brelease(XEvent *e) 716 { 717 int btn = e->xbutton.button; 718 719 if (1 <= btn && btn <= 11) 720 buttons &= ~(1 << (btn-1)); 721 722 if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) { 723 mousereport(e); 724 return; 725 } 726 727 if (mouseaction(e, 1)) 728 return; 729 if (btn == Button1) 730 mousesel(e, 1); 731 } 732 733 void 734 bmotion(XEvent *e) 735 { 736 if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) { 737 mousereport(e); 738 return; 739 } 740 741 mousesel(e, 0); 742 } 743 744 void 745 cresize(int width, int height) 746 { 747 int col, row; 748 749 if (width != 0) 750 win.w = width; 751 if (height != 0) 752 win.h = height; 753 754 col = (win.w - 2 * borderpx) / win.cw; 755 row = (win.h - 2 * borderpx) / win.ch; 756 col = MAX(1, col); 757 row = MAX(1, row); 758 759 win.hborderpx = (win.w - col * win.cw) / 2; 760 win.vborderpx = (win.h - row * win.ch) / 2; 761 762 tresize(col, row); 763 xresize(col, row); 764 ttyresize(win.tw, win.th); 765 } 766 767 void 768 xresize(int col, int row) 769 { 770 win.tw = col * win.cw; 771 win.th = row * win.ch; 772 773 XFreePixmap(xw.dpy, xw.buf); 774 xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h, 775 DefaultDepth(xw.dpy, xw.scr)); 776 XftDrawChange(xw.draw, xw.buf); 777 xclear(0, 0, win.w, win.h); 778 779 /* resize to new width */ 780 xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec)); 781 } 782 783 ushort 784 sixd_to_16bit(int x) 785 { 786 return x == 0 ? 0 : 0x3737 + 0x2828 * x; 787 } 788 789 int 790 xloadcolor(int i, const char *name, Color *ncolor) 791 { 792 XRenderColor color = { .alpha = 0xffff }; 793 794 if (!name) { 795 if (BETWEEN(i, 16, 255)) { /* 256 color */ 796 if (i < 6*6*6+16) { /* same colors as xterm */ 797 color.red = sixd_to_16bit( ((i-16)/36)%6 ); 798 color.green = sixd_to_16bit( ((i-16)/6) %6 ); 799 color.blue = sixd_to_16bit( ((i-16)/1) %6 ); 800 } else { /* greyscale */ 801 color.red = 0x0808 + 0x0a0a * (i - (6*6*6+16)); 802 color.green = color.blue = color.red; 803 } 804 return XftColorAllocValue(xw.dpy, xw.vis, 805 xw.cmap, &color, ncolor); 806 } else 807 name = colorname[i]; 808 } 809 810 return XftColorAllocName(xw.dpy, xw.vis, xw.cmap, name, ncolor); 811 } 812 813 void 814 xloadcols(void) 815 { 816 int i; 817 static int loaded; 818 Color *cp; 819 820 if (loaded) { 821 for (cp = dc.col; cp < &dc.col[dc.collen]; ++cp) 822 XftColorFree(xw.dpy, xw.vis, xw.cmap, cp); 823 } else { 824 dc.collen = MAX(LEN(colorname), 256); 825 dc.col = xmalloc(dc.collen * sizeof(Color)); 826 } 827 828 for (i = 0; i < dc.collen; i++) 829 if (!xloadcolor(i, NULL, &dc.col[i])) { 830 if (colorname[i]) 831 die("could not allocate color '%s'\n", colorname[i]); 832 else 833 die("could not allocate color %d\n", i); 834 } 835 loaded = 1; 836 } 837 838 int 839 xgetcolor(int x, unsigned char *r, unsigned char *g, unsigned char *b) 840 { 841 if (!BETWEEN(x, 0, dc.collen - 1)) 842 return 1; 843 844 *r = dc.col[x].color.red >> 8; 845 *g = dc.col[x].color.green >> 8; 846 *b = dc.col[x].color.blue >> 8; 847 848 return 0; 849 } 850 851 int 852 xsetcolorname(int x, const char *name) 853 { 854 Color ncolor; 855 856 if (!BETWEEN(x, 0, dc.collen - 1)) 857 return 1; 858 859 if (!xloadcolor(x, name, &ncolor)) 860 return 1; 861 862 XftColorFree(xw.dpy, xw.vis, xw.cmap, &dc.col[x]); 863 dc.col[x] = ncolor; 864 865 return 0; 866 } 867 868 /* 869 * Absolute coordinates. 870 */ 871 void 872 xclear(int x1, int y1, int x2, int y2) 873 { 874 XftDrawRect(xw.draw, 875 &dc.col[IS_SET(MODE_REVERSE)? defaultfg : defaultbg], 876 x1, y1, x2-x1, y2-y1); 877 } 878 879 void 880 xhints(void) 881 { 882 XClassHint class = {opt_name ? opt_name : termname, 883 opt_class ? opt_class : termname}; 884 XWMHints wm = {.flags = InputHint, .input = 1}; 885 XSizeHints *sizeh; 886 887 sizeh = XAllocSizeHints(); 888 889 sizeh->flags = PSize | PResizeInc | PBaseSize | PMinSize; 890 sizeh->height = win.h; 891 sizeh->width = win.w; 892 sizeh->height_inc = 1; 893 sizeh->width_inc = 1; 894 sizeh->base_height = 2 * borderpx; 895 sizeh->base_width = 2 * borderpx; 896 sizeh->min_height = win.ch + 2 * borderpx; 897 sizeh->min_width = win.cw + 2 * borderpx; 898 if (xw.isfixed) { 899 sizeh->flags |= PMaxSize; 900 sizeh->min_width = sizeh->max_width = win.w; 901 sizeh->min_height = sizeh->max_height = win.h; 902 } 903 if (xw.gm & (XValue|YValue)) { 904 sizeh->flags |= USPosition | PWinGravity; 905 sizeh->x = xw.l; 906 sizeh->y = xw.t; 907 sizeh->win_gravity = xgeommasktogravity(xw.gm); 908 } 909 910 XSetWMProperties(xw.dpy, xw.win, NULL, NULL, NULL, 0, sizeh, &wm, 911 &class); 912 XFree(sizeh); 913 } 914 915 int 916 xgeommasktogravity(int mask) 917 { 918 switch (mask & (XNegative|YNegative)) { 919 case 0: 920 return NorthWestGravity; 921 case XNegative: 922 return NorthEastGravity; 923 case YNegative: 924 return SouthWestGravity; 925 } 926 927 return SouthEastGravity; 928 } 929 930 int 931 xloadfont(Font *f, FcPattern *pattern) 932 { 933 FcPattern *configured; 934 FcPattern *match; 935 FcResult result; 936 XGlyphInfo extents; 937 int wantattr, haveattr; 938 939 /* 940 * Manually configure instead of calling XftMatchFont 941 * so that we can use the configured pattern for 942 * "missing glyph" lookups. 943 */ 944 configured = FcPatternDuplicate(pattern); 945 if (!configured) 946 return 1; 947 948 FcConfigSubstitute(NULL, configured, FcMatchPattern); 949 XftDefaultSubstitute(xw.dpy, xw.scr, configured); 950 951 match = FcFontMatch(NULL, configured, &result); 952 if (!match) { 953 FcPatternDestroy(configured); 954 return 1; 955 } 956 957 if (!(f->match = XftFontOpenPattern(xw.dpy, match))) { 958 FcPatternDestroy(configured); 959 FcPatternDestroy(match); 960 return 1; 961 } 962 963 if ((XftPatternGetInteger(pattern, "slant", 0, &wantattr) == 964 XftResultMatch)) { 965 /* 966 * Check if xft was unable to find a font with the appropriate 967 * slant but gave us one anyway. Try to mitigate. 968 */ 969 if ((XftPatternGetInteger(f->match->pattern, "slant", 0, 970 &haveattr) != XftResultMatch) || haveattr < wantattr) { 971 f->badslant = 1; 972 fputs("font slant does not match\n", stderr); 973 } 974 } 975 976 if ((XftPatternGetInteger(pattern, "weight", 0, &wantattr) == 977 XftResultMatch)) { 978 if ((XftPatternGetInteger(f->match->pattern, "weight", 0, 979 &haveattr) != XftResultMatch) || haveattr != wantattr) { 980 f->badweight = 1; 981 fputs("font weight does not match\n", stderr); 982 } 983 } 984 985 XftTextExtentsUtf8(xw.dpy, f->match, 986 (const FcChar8 *) ascii_printable, 987 strlen(ascii_printable), &extents); 988 989 f->set = NULL; 990 f->pattern = configured; 991 992 f->ascent = f->match->ascent; 993 f->descent = f->match->descent; 994 f->lbearing = 0; 995 f->rbearing = f->match->max_advance_width; 996 997 f->height = f->ascent + f->descent; 998 f->width = DIVCEIL(extents.xOff, strlen(ascii_printable)); 999 1000 return 0; 1001 } 1002 1003 void 1004 xloadfonts(const char *fontstr, double fontsize) 1005 { 1006 FcPattern *pattern; 1007 double fontval; 1008 1009 if (fontstr[0] == '-') 1010 pattern = XftXlfdParse(fontstr, False, False); 1011 else 1012 pattern = FcNameParse((const FcChar8 *)fontstr); 1013 1014 if (!pattern) 1015 die("can't open font %s\n", fontstr); 1016 1017 if (fontsize > 1) { 1018 FcPatternDel(pattern, FC_PIXEL_SIZE); 1019 FcPatternDel(pattern, FC_SIZE); 1020 FcPatternAddDouble(pattern, FC_PIXEL_SIZE, (double)fontsize); 1021 usedfontsize = fontsize; 1022 } else { 1023 if (FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &fontval) == 1024 FcResultMatch) { 1025 usedfontsize = fontval; 1026 } else if (FcPatternGetDouble(pattern, FC_SIZE, 0, &fontval) == 1027 FcResultMatch) { 1028 usedfontsize = -1; 1029 } else { 1030 /* 1031 * Default font size is 12, if none given. This is to 1032 * have a known usedfontsize value. 1033 */ 1034 FcPatternAddDouble(pattern, FC_PIXEL_SIZE, 12); 1035 usedfontsize = 12; 1036 } 1037 defaultfontsize = usedfontsize; 1038 } 1039 1040 if (xloadfont(&dc.font, pattern)) 1041 die("can't open font %s\n", fontstr); 1042 1043 if (usedfontsize < 0) { 1044 FcPatternGetDouble(dc.font.match->pattern, 1045 FC_PIXEL_SIZE, 0, &fontval); 1046 usedfontsize = fontval; 1047 if (fontsize == 0) 1048 defaultfontsize = fontval; 1049 } 1050 1051 /* Setting character width and height. */ 1052 win.cw = ceilf(dc.font.width * cwscale); 1053 win.ch = ceilf(dc.font.height * chscale); 1054 1055 FcPatternDel(pattern, FC_SLANT); 1056 FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC); 1057 if (xloadfont(&dc.ifont, pattern)) 1058 die("can't open font %s\n", fontstr); 1059 1060 FcPatternDel(pattern, FC_WEIGHT); 1061 FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD); 1062 if (xloadfont(&dc.ibfont, pattern)) 1063 die("can't open font %s\n", fontstr); 1064 1065 FcPatternDel(pattern, FC_SLANT); 1066 FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ROMAN); 1067 if (xloadfont(&dc.bfont, pattern)) 1068 die("can't open font %s\n", fontstr); 1069 1070 FcPatternDestroy(pattern); 1071 } 1072 1073 void 1074 xunloadfont(Font *f) 1075 { 1076 XftFontClose(xw.dpy, f->match); 1077 FcPatternDestroy(f->pattern); 1078 if (f->set) 1079 FcFontSetDestroy(f->set); 1080 } 1081 1082 void 1083 xunloadfonts(void) 1084 { 1085 /* Free the loaded fonts in the font cache. */ 1086 while (frclen > 0) 1087 XftFontClose(xw.dpy, frc[--frclen].font); 1088 1089 xunloadfont(&dc.font); 1090 xunloadfont(&dc.bfont); 1091 xunloadfont(&dc.ifont); 1092 xunloadfont(&dc.ibfont); 1093 } 1094 1095 int 1096 ximopen(Display *dpy) 1097 { 1098 XIMCallback imdestroy = { .client_data = NULL, .callback = ximdestroy }; 1099 XICCallback icdestroy = { .client_data = NULL, .callback = xicdestroy }; 1100 1101 xw.ime.xim = XOpenIM(xw.dpy, NULL, NULL, NULL); 1102 if (xw.ime.xim == NULL) 1103 return 0; 1104 1105 if (XSetIMValues(xw.ime.xim, XNDestroyCallback, &imdestroy, NULL)) 1106 fprintf(stderr, "XSetIMValues: " 1107 "Could not set XNDestroyCallback.\n"); 1108 1109 xw.ime.spotlist = XVaCreateNestedList(0, XNSpotLocation, &xw.ime.spot, 1110 NULL); 1111 1112 if (xw.ime.xic == NULL) { 1113 xw.ime.xic = XCreateIC(xw.ime.xim, XNInputStyle, 1114 XIMPreeditNothing | XIMStatusNothing, 1115 XNClientWindow, xw.win, 1116 XNDestroyCallback, &icdestroy, 1117 NULL); 1118 } 1119 if (xw.ime.xic == NULL) 1120 fprintf(stderr, "XCreateIC: Could not create input context.\n"); 1121 1122 return 1; 1123 } 1124 1125 void 1126 ximinstantiate(Display *dpy, XPointer client, XPointer call) 1127 { 1128 if (ximopen(dpy)) 1129 XUnregisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL, 1130 ximinstantiate, NULL); 1131 } 1132 1133 void 1134 ximdestroy(XIM xim, XPointer client, XPointer call) 1135 { 1136 xw.ime.xim = NULL; 1137 XRegisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL, 1138 ximinstantiate, NULL); 1139 XFree(xw.ime.spotlist); 1140 } 1141 1142 int 1143 xicdestroy(XIC xim, XPointer client, XPointer call) 1144 { 1145 xw.ime.xic = NULL; 1146 return 1; 1147 } 1148 1149 void 1150 xreloadfont(void) 1151 { 1152 usedfont = (opt_font == NULL)? fonts[curfont] : opt_font; 1153 xunloadfonts(); 1154 xloadfonts(usedfont, 0); 1155 } 1156 1157 void 1158 xinit(int cols, int rows) 1159 { 1160 XGCValues gcvalues; 1161 Cursor cursor; 1162 Window parent; 1163 pid_t thispid = getpid(); 1164 XColor xmousefg, xmousebg; 1165 1166 if (!(xw.dpy = XOpenDisplay(NULL))) 1167 die("can't open display\n"); 1168 xw.scr = XDefaultScreen(xw.dpy); 1169 xw.vis = XDefaultVisual(xw.dpy, xw.scr); 1170 1171 /* font */ 1172 if (!FcInit()) 1173 die("could not init fontconfig.\n"); 1174 1175 usedfont = (opt_font == NULL)? fonts[curfont] : opt_font; 1176 xloadfonts(usedfont, 0); 1177 1178 /* colors */ 1179 xw.cmap = XDefaultColormap(xw.dpy, xw.scr); 1180 xloadcols(); 1181 1182 /* adjust fixed window geometry */ 1183 win.w = 2 * win.hborderpx + 2 * borderpx + cols * win.cw; 1184 win.h = 2 * win.vborderpx + 2 * borderpx + rows * win.ch; 1185 if (xw.gm & XNegative) 1186 xw.l += DisplayWidth(xw.dpy, xw.scr) - win.w - 2; 1187 if (xw.gm & YNegative) 1188 xw.t += DisplayHeight(xw.dpy, xw.scr) - win.h - 2; 1189 1190 /* Events */ 1191 xw.attrs.background_pixel = dc.col[defaultbg].pixel; 1192 xw.attrs.border_pixel = dc.col[defaultbg].pixel; 1193 xw.attrs.bit_gravity = NorthWestGravity; 1194 xw.attrs.event_mask = FocusChangeMask | KeyPressMask | KeyReleaseMask 1195 | ExposureMask | VisibilityChangeMask | StructureNotifyMask 1196 | ButtonMotionMask | ButtonPressMask | ButtonReleaseMask; 1197 xw.attrs.colormap = xw.cmap; 1198 1199 if (!(opt_embed && (parent = strtol(opt_embed, NULL, 0)))) 1200 parent = XRootWindow(xw.dpy, xw.scr); 1201 xw.win = XCreateWindow(xw.dpy, parent, xw.l, xw.t, 1202 win.w, win.h, 0, XDefaultDepth(xw.dpy, xw.scr), InputOutput, 1203 xw.vis, CWBackPixel | CWBorderPixel | CWBitGravity 1204 | CWEventMask | CWColormap, &xw.attrs); 1205 1206 memset(&gcvalues, 0, sizeof(gcvalues)); 1207 gcvalues.graphics_exposures = False; 1208 dc.gc = XCreateGC(xw.dpy, parent, GCGraphicsExposures, 1209 &gcvalues); 1210 xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h, 1211 DefaultDepth(xw.dpy, xw.scr)); 1212 XSetForeground(xw.dpy, dc.gc, dc.col[defaultbg].pixel); 1213 XFillRectangle(xw.dpy, xw.buf, dc.gc, 0, 0, win.w, win.h); 1214 1215 /* font spec buffer */ 1216 xw.specbuf = xmalloc(cols * sizeof(GlyphFontSpec)); 1217 1218 /* Xft rendering context */ 1219 xw.draw = XftDrawCreate(xw.dpy, xw.buf, xw.vis, xw.cmap); 1220 1221 /* input methods */ 1222 if (!ximopen(xw.dpy)) { 1223 XRegisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL, 1224 ximinstantiate, NULL); 1225 } 1226 1227 /* white cursor, black outline */ 1228 cursor = XcursorLibraryLoadCursor(xw.dpy, mouseshape); 1229 XDefineCursor(xw.dpy, xw.win, cursor); 1230 1231 xw.xembed = XInternAtom(xw.dpy, "_XEMBED", False); 1232 xw.wmdeletewin = XInternAtom(xw.dpy, "WM_DELETE_WINDOW", False); 1233 xw.netwmname = XInternAtom(xw.dpy, "_NET_WM_NAME", False); 1234 xw.netwmiconname = XInternAtom(xw.dpy, "_NET_WM_ICON_NAME", False); 1235 XSetWMProtocols(xw.dpy, xw.win, &xw.wmdeletewin, 1); 1236 1237 xw.netwmpid = XInternAtom(xw.dpy, "_NET_WM_PID", False); 1238 XChangeProperty(xw.dpy, xw.win, xw.netwmpid, XA_CARDINAL, 32, 1239 PropModeReplace, (uchar *)&thispid, 1); 1240 1241 win.mode = MODE_NUMLOCK; 1242 resettitle(); 1243 xhints(); 1244 XMapWindow(xw.dpy, xw.win); 1245 XSync(xw.dpy, False); 1246 1247 clock_gettime(CLOCK_MONOTONIC, &xsel.tclick1); 1248 clock_gettime(CLOCK_MONOTONIC, &xsel.tclick2); 1249 xsel.primary = NULL; 1250 xsel.clipboard = NULL; 1251 xsel.xtarget = XInternAtom(xw.dpy, "UTF8_STRING", 0); 1252 if (xsel.xtarget == None) 1253 xsel.xtarget = XA_STRING; 1254 1255 boxdraw_xinit(xw.dpy, xw.cmap, xw.draw, xw.vis); 1256 } 1257 1258 int 1259 xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x, int y) 1260 { 1261 float winx = win.hborderpx + x * win.cw, winy = win.vborderpx + y * win.ch, xp, yp; 1262 ushort mode, prevmode = USHRT_MAX; 1263 Font *font = &dc.font; 1264 int frcflags = FRC_NORMAL; 1265 float runewidth = win.cw; 1266 Rune rune; 1267 FT_UInt glyphidx; 1268 FcResult fcres; 1269 FcPattern *fcpattern, *fontpattern; 1270 FcFontSet *fcsets[] = { NULL }; 1271 FcCharSet *fccharset; 1272 int i, f, numspecs = 0; 1273 1274 for (i = 0, xp = winx, yp = winy + font->ascent; i < len; ++i) { 1275 /* Fetch rune and mode for current glyph. */ 1276 rune = glyphs[i].u; 1277 mode = glyphs[i].mode; 1278 1279 /* Skip dummy wide-character spacing. */ 1280 if (mode == ATTR_WDUMMY) 1281 continue; 1282 1283 /* Determine font for glyph if different from previous glyph. */ 1284 if (prevmode != mode) { 1285 prevmode = mode; 1286 font = &dc.font; 1287 frcflags = FRC_NORMAL; 1288 runewidth = win.cw * ((mode & ATTR_WIDE) ? 2.0f : 1.0f); 1289 if ((mode & ATTR_ITALIC) && (mode & ATTR_BOLD)) { 1290 font = &dc.ibfont; 1291 frcflags = FRC_ITALICBOLD; 1292 } else if (mode & ATTR_ITALIC) { 1293 font = &dc.ifont; 1294 frcflags = FRC_ITALIC; 1295 } else if (mode & ATTR_BOLD) { 1296 font = &dc.bfont; 1297 frcflags = FRC_BOLD; 1298 } 1299 yp = winy + font->ascent; 1300 } 1301 1302 if (mode & ATTR_BOXDRAW) { 1303 /* minor shoehorning: boxdraw uses only this ushort */ 1304 glyphidx = boxdrawindex(&glyphs[i]); 1305 } else { 1306 /* Lookup character index with default font. */ 1307 glyphidx = XftCharIndex(xw.dpy, font->match, rune); 1308 } 1309 if (glyphidx) { 1310 specs[numspecs].font = font->match; 1311 specs[numspecs].glyph = glyphidx; 1312 specs[numspecs].x = (short)xp; 1313 specs[numspecs].y = (short)yp; 1314 xp += runewidth; 1315 numspecs++; 1316 continue; 1317 } 1318 1319 /* Fallback on font cache, search the font cache for match. */ 1320 for (f = 0; f < frclen; f++) { 1321 glyphidx = XftCharIndex(xw.dpy, frc[f].font, rune); 1322 /* Everything correct. */ 1323 if (glyphidx && frc[f].flags == frcflags) 1324 break; 1325 /* We got a default font for a not found glyph. */ 1326 if (!glyphidx && frc[f].flags == frcflags 1327 && frc[f].unicodep == rune) { 1328 break; 1329 } 1330 } 1331 1332 /* Nothing was found. Use fontconfig to find matching font. */ 1333 if (f >= frclen) { 1334 if (!font->set) 1335 font->set = FcFontSort(0, font->pattern, 1336 1, 0, &fcres); 1337 fcsets[0] = font->set; 1338 1339 /* 1340 * Nothing was found in the cache. Now use 1341 * some dozen of Fontconfig calls to get the 1342 * font for one single character. 1343 * 1344 * Xft and fontconfig are design failures. 1345 */ 1346 fcpattern = FcPatternDuplicate(font->pattern); 1347 fccharset = FcCharSetCreate(); 1348 1349 FcCharSetAddChar(fccharset, rune); 1350 FcPatternAddCharSet(fcpattern, FC_CHARSET, 1351 fccharset); 1352 FcPatternAddBool(fcpattern, FC_SCALABLE, 1); 1353 1354 FcConfigSubstitute(0, fcpattern, 1355 FcMatchPattern); 1356 FcDefaultSubstitute(fcpattern); 1357 1358 fontpattern = FcFontSetMatch(0, fcsets, 1, 1359 fcpattern, &fcres); 1360 1361 /* Allocate memory for the new cache entry. */ 1362 if (frclen >= frccap) { 1363 frccap += 16; 1364 frc = xrealloc(frc, frccap * sizeof(Fontcache)); 1365 } 1366 1367 frc[frclen].font = XftFontOpenPattern(xw.dpy, 1368 fontpattern); 1369 if (!frc[frclen].font) 1370 die("XftFontOpenPattern failed seeking fallback font: %s\n", 1371 strerror(errno)); 1372 frc[frclen].flags = frcflags; 1373 frc[frclen].unicodep = rune; 1374 1375 glyphidx = XftCharIndex(xw.dpy, frc[frclen].font, rune); 1376 1377 f = frclen; 1378 frclen++; 1379 1380 FcPatternDestroy(fcpattern); 1381 FcCharSetDestroy(fccharset); 1382 } 1383 1384 specs[numspecs].font = frc[f].font; 1385 specs[numspecs].glyph = glyphidx; 1386 specs[numspecs].x = (short)xp; 1387 specs[numspecs].y = (short)yp; 1388 xp += runewidth; 1389 numspecs++; 1390 } 1391 1392 return numspecs; 1393 } 1394 1395 void 1396 xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, int y, int dmode) 1397 { 1398 int charlen = len * ((base.mode & ATTR_WIDE) ? 2 : 1); 1399 int winx = win.hborderpx + x * win.cw, winy = win.vborderpx + y * win.ch, 1400 width = charlen * win.cw; 1401 Color *fg, *bg, *temp, revfg, revbg, truefg, truebg; 1402 XRenderColor colfg, colbg; 1403 XRectangle r; 1404 1405 /* Fallback on color display for attributes not supported by the font */ 1406 if (base.mode & ATTR_ITALIC && base.mode & ATTR_BOLD) { 1407 if (dc.ibfont.badslant || dc.ibfont.badweight) 1408 base.fg = defaultattr; 1409 } else if ((base.mode & ATTR_ITALIC && dc.ifont.badslant) || 1410 (base.mode & ATTR_BOLD && dc.bfont.badweight)) { 1411 base.fg = defaultattr; 1412 } 1413 1414 if (IS_TRUECOL(base.fg)) { 1415 colfg.alpha = 0xffff; 1416 colfg.red = TRUERED(base.fg); 1417 colfg.green = TRUEGREEN(base.fg); 1418 colfg.blue = TRUEBLUE(base.fg); 1419 XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colfg, &truefg); 1420 fg = &truefg; 1421 } else { 1422 fg = &dc.col[base.fg]; 1423 } 1424 1425 if (IS_TRUECOL(base.bg)) { 1426 colbg.alpha = 0xffff; 1427 colbg.green = TRUEGREEN(base.bg); 1428 colbg.red = TRUERED(base.bg); 1429 colbg.blue = TRUEBLUE(base.bg); 1430 XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colbg, &truebg); 1431 bg = &truebg; 1432 } else { 1433 bg = &dc.col[base.bg]; 1434 } 1435 1436 if (IS_SET(MODE_REVERSE)) { 1437 if (fg == &dc.col[defaultfg]) { 1438 fg = &dc.col[defaultbg]; 1439 } else { 1440 colfg.red = ~fg->color.red; 1441 colfg.green = ~fg->color.green; 1442 colfg.blue = ~fg->color.blue; 1443 colfg.alpha = fg->color.alpha; 1444 XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colfg, 1445 &revfg); 1446 fg = &revfg; 1447 } 1448 1449 if (bg == &dc.col[defaultbg]) { 1450 bg = &dc.col[defaultfg]; 1451 } else { 1452 colbg.red = ~bg->color.red; 1453 colbg.green = ~bg->color.green; 1454 colbg.blue = ~bg->color.blue; 1455 colbg.alpha = bg->color.alpha; 1456 XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colbg, 1457 &revbg); 1458 bg = &revbg; 1459 } 1460 } 1461 1462 if ((base.mode & ATTR_BOLD_FAINT) == ATTR_FAINT) { 1463 colfg.red = fg->color.red / 2; 1464 colfg.green = fg->color.green / 2; 1465 colfg.blue = fg->color.blue / 2; 1466 colfg.alpha = fg->color.alpha; 1467 XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colfg, &revfg); 1468 fg = &revfg; 1469 } 1470 1471 if (base.mode & ATTR_REVERSE) { 1472 temp = fg; 1473 fg = bg; 1474 bg = temp; 1475 } 1476 1477 if (base.mode & ATTR_BLINK && win.mode & MODE_BLINK) 1478 fg = bg; 1479 1480 if (base.mode & ATTR_INVISIBLE) 1481 fg = bg; 1482 1483 if (dmode & DRAW_BG) { 1484 /* Intelligent cleaning up of the borders. */ 1485 if (x == 0) { 1486 xclear(0, (y == 0)? 0 : winy, borderpx, 1487 winy + win.ch + 1488 ((winy + win.ch >= borderpx + win.th)? win.h : 0)); 1489 } 1490 if (winx + width >= borderpx + win.tw) { 1491 xclear(winx + width, (y == 0)? 0 : winy, win.w, 1492 ((winy + win.ch >= borderpx + win.th)? win.h : (winy + win.ch))); 1493 } 1494 if (y == 0) 1495 xclear(winx, 0, winx + width, borderpx); 1496 if (winy + win.ch >= borderpx + win.th) 1497 xclear(winx, winy + win.ch, winx + width, win.h); 1498 /* Fill the background */ 1499 XftDrawRect(xw.draw, bg, winx, winy, width, win.ch); 1500 } 1501 1502 if (dmode & DRAW_FG) { 1503 if (base.mode & ATTR_BOXDRAW) { 1504 drawboxes(winx, winy, width / len, win.ch, fg, bg, specs, len); 1505 } else { 1506 /* Render the glyphs. */ 1507 XftDrawGlyphFontSpec(xw.draw, fg, specs, len); 1508 } 1509 /* Render underline and strikethrough. */ 1510 if (base.mode & ATTR_UNDERLINE) { 1511 XftDrawRect(xw.draw, fg, winx, winy + dc.font.ascent + 1, 1512 width, 1); 1513 } 1514 if (base.mode & ATTR_STRUCK) { 1515 XftDrawRect(xw.draw, fg, winx, winy + 2 * dc.font.ascent / 3, 1516 width, 1); 1517 } 1518 } 1519 } 1520 1521 void 1522 xdrawglyph(Glyph g, int x, int y) 1523 { 1524 int numspecs; 1525 XftGlyphFontSpec spec; 1526 1527 numspecs = xmakeglyphfontspecs(&spec, &g, 1, x, y); 1528 xdrawglyphfontspecs(&spec, g, numspecs, x, y, DRAW_BG | DRAW_FG); 1529 } 1530 1531 void 1532 xdrawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og) 1533 { 1534 Color drawcol; 1535 1536 /* remove the old cursor */ 1537 if (selected(ox, oy)) 1538 og.mode ^= ATTR_REVERSE; 1539 xdrawglyph(og, ox, oy); 1540 1541 if (IS_SET(MODE_HIDE)) 1542 return; 1543 1544 /* 1545 * Select the right color for the right mode. 1546 */ 1547 g.mode &= ATTR_BOLD|ATTR_ITALIC|ATTR_UNDERLINE|ATTR_STRUCK|ATTR_WIDE|ATTR_BOXDRAW; 1548 1549 if (IS_SET(MODE_REVERSE)) { 1550 g.mode |= ATTR_REVERSE; 1551 g.bg = defaultfg; 1552 if (selected(cx, cy)) { 1553 drawcol = dc.col[defaultcs]; 1554 g.fg = defaultrcs; 1555 } else { 1556 drawcol = dc.col[defaultrcs]; 1557 g.fg = defaultcs; 1558 } 1559 } else { 1560 if (selected(cx, cy)) { 1561 g.fg = defaultfg; 1562 g.bg = defaultrcs; 1563 } else { 1564 g.fg = defaultbg; 1565 g.bg = defaultcs; 1566 } 1567 drawcol = dc.col[g.bg]; 1568 } 1569 1570 /* draw the new one */ 1571 if (IS_SET(MODE_FOCUSED)) { 1572 switch (win.cursor) { 1573 case 7: /* st extension */ 1574 g.u = 0x2603; /* snowman (U+2603) */ 1575 /* FALLTHROUGH */ 1576 case 0: /* Blinking Block */ 1577 case 1: /* Blinking Block (Default) */ 1578 case 2: /* Steady Block */ 1579 xdrawglyph(g, cx, cy); 1580 break; 1581 case 3: /* Blinking Underline */ 1582 case 4: /* Steady Underline */ 1583 XftDrawRect(xw.draw, &drawcol, 1584 win.hborderpx + cx * win.cw, 1585 win.vborderpx + (cy + 1) * win.ch - \ 1586 cursorthickness, 1587 win.cw, cursorthickness); 1588 break; 1589 case 5: /* Blinking bar */ 1590 case 6: /* Steady bar */ 1591 XftDrawRect(xw.draw, &drawcol, 1592 win.hborderpx + cx * win.cw, 1593 win.vborderpx + cy * win.ch, 1594 cursorthickness, win.ch); 1595 break; 1596 } 1597 } else { 1598 XftDrawRect(xw.draw, &drawcol, 1599 win.hborderpx + cx * win.cw, 1600 win.vborderpx + cy * win.ch, 1601 win.cw - 1, 1); 1602 XftDrawRect(xw.draw, &drawcol, 1603 win.hborderpx + cx * win.cw, 1604 win.vborderpx + cy * win.ch, 1605 1, win.ch - 1); 1606 XftDrawRect(xw.draw, &drawcol, 1607 win.hborderpx + (cx + 1) * win.cw - 1, 1608 win.vborderpx + cy * win.ch, 1609 1, win.ch - 1); 1610 XftDrawRect(xw.draw, &drawcol, 1611 win.hborderpx + cx * win.cw, 1612 win.vborderpx + (cy + 1) * win.ch - 1, 1613 win.cw, 1); 1614 } 1615 } 1616 1617 void 1618 xsetenv(void) 1619 { 1620 char buf[sizeof(long) * 8 + 1]; 1621 1622 snprintf(buf, sizeof(buf), "%lu", xw.win); 1623 setenv("WINDOWID", buf, 1); 1624 } 1625 1626 void 1627 xseticontitle(char *p) 1628 { 1629 XTextProperty prop; 1630 DEFAULT(p, opt_title); 1631 1632 if (p[0] == '\0') 1633 p = opt_title; 1634 1635 if (Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle, 1636 &prop) != Success) 1637 return; 1638 XSetWMIconName(xw.dpy, xw.win, &prop); 1639 XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmiconname); 1640 XFree(prop.value); 1641 } 1642 1643 void 1644 xsettitle(char *p) 1645 { 1646 XTextProperty prop; 1647 DEFAULT(p, opt_title); 1648 1649 if (p[0] == '\0') 1650 p = opt_title; 1651 1652 if (Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle, 1653 &prop) != Success) 1654 return; 1655 XSetWMName(xw.dpy, xw.win, &prop); 1656 XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmname); 1657 XFree(prop.value); 1658 } 1659 1660 int 1661 xstartdraw(void) 1662 { 1663 return IS_SET(MODE_VISIBLE); 1664 } 1665 1666 void 1667 xdrawline(Line line, int x1, int y1, int x2) 1668 { 1669 int i, x, ox, numspecs, numspecs_cached; 1670 Glyph base, new; 1671 XftGlyphFontSpec *specs; 1672 1673 numspecs_cached = xmakeglyphfontspecs(xw.specbuf, &line[x1], x2 - x1, x1, y1); 1674 1675 /* Draw line in 2 passes: background and foreground. This way wide glyphs 1676 won't get truncated (#223) */ 1677 for (int dmode = DRAW_BG; dmode <= DRAW_FG; dmode <<= 1) { 1678 specs = xw.specbuf; 1679 numspecs = numspecs_cached; 1680 i = ox = 0; 1681 for (x = x1; x < x2 && i < numspecs; x++) { 1682 new = line[x]; 1683 if (new.mode == ATTR_WDUMMY) 1684 continue; 1685 if (selected(x, y1)) 1686 new.mode ^= ATTR_REVERSE; 1687 if (i > 0 && ATTRCMP(base, new)) { 1688 xdrawglyphfontspecs(specs, base, i, ox, y1, dmode); 1689 specs += i; 1690 numspecs -= i; 1691 i = 0; 1692 } 1693 if (i == 0) { 1694 ox = x; 1695 base = new; 1696 } 1697 i++; 1698 } 1699 if (i > 0) 1700 xdrawglyphfontspecs(specs, base, i, ox, y1, dmode); 1701 } 1702 } 1703 1704 void 1705 xfinishdraw(void) 1706 { 1707 XCopyArea(xw.dpy, xw.buf, xw.win, dc.gc, 0, 0, win.w, 1708 win.h, 0, 0); 1709 XSetForeground(xw.dpy, dc.gc, 1710 dc.col[IS_SET(MODE_REVERSE)? 1711 defaultfg : defaultbg].pixel); 1712 } 1713 1714 void 1715 xximspot(int x, int y) 1716 { 1717 if (xw.ime.xic == NULL) 1718 return; 1719 1720 xw.ime.spot.x = borderpx + x * win.cw; 1721 xw.ime.spot.y = borderpx + (y + 1) * win.ch; 1722 1723 XSetICValues(xw.ime.xic, XNPreeditAttributes, xw.ime.spotlist, NULL); 1724 } 1725 1726 void 1727 expose(XEvent *ev) 1728 { 1729 redraw(); 1730 } 1731 1732 void 1733 visibility(XEvent *ev) 1734 { 1735 XVisibilityEvent *e = &ev->xvisibility; 1736 1737 MODBIT(win.mode, e->state != VisibilityFullyObscured, MODE_VISIBLE); 1738 } 1739 1740 void 1741 unmap(XEvent *ev) 1742 { 1743 win.mode &= ~MODE_VISIBLE; 1744 } 1745 1746 void 1747 xsetpointermotion(int set) 1748 { 1749 MODBIT(xw.attrs.event_mask, set, PointerMotionMask); 1750 XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, &xw.attrs); 1751 } 1752 1753 void 1754 xsetmode(int set, unsigned int flags) 1755 { 1756 int mode = win.mode; 1757 MODBIT(win.mode, set, flags); 1758 if ((win.mode & MODE_REVERSE) != (mode & MODE_REVERSE)) 1759 redraw(); 1760 } 1761 1762 int 1763 xsetcursor(int cursor) 1764 { 1765 if (!BETWEEN(cursor, 0, 7)) /* 7: st extension */ 1766 return 1; 1767 win.cursor = cursor; 1768 return 0; 1769 } 1770 1771 void 1772 xseturgency(int add) 1773 { 1774 XWMHints *h = XGetWMHints(xw.dpy, xw.win); 1775 1776 MODBIT(h->flags, add, XUrgencyHint); 1777 XSetWMHints(xw.dpy, xw.win, h); 1778 XFree(h); 1779 } 1780 1781 void 1782 xbell(void) 1783 { 1784 if (!(IS_SET(MODE_FOCUSED))) 1785 xseturgency(1); 1786 if (bellvolume) 1787 XkbBell(xw.dpy, xw.win, bellvolume, (Atom)NULL); 1788 } 1789 1790 void 1791 focus(XEvent *ev) 1792 { 1793 XFocusChangeEvent *e = &ev->xfocus; 1794 1795 if (e->mode == NotifyGrab) 1796 return; 1797 1798 if (ev->type == FocusIn) { 1799 if (xw.ime.xic) 1800 XSetICFocus(xw.ime.xic); 1801 win.mode |= MODE_FOCUSED; 1802 xseturgency(0); 1803 if (IS_SET(MODE_FOCUS)) 1804 ttywrite("\033[I", 3, 0); 1805 } else { 1806 if (xw.ime.xic) 1807 XUnsetICFocus(xw.ime.xic); 1808 win.mode &= ~MODE_FOCUSED; 1809 if (IS_SET(MODE_FOCUS)) 1810 ttywrite("\033[O", 3, 0); 1811 } 1812 } 1813 1814 int 1815 match(uint mask, uint state) 1816 { 1817 return mask == XK_ANY_MOD || mask == (state & ~ignoremod); 1818 } 1819 1820 char* 1821 kmap(KeySym k, uint state) 1822 { 1823 Key *kp; 1824 int i; 1825 1826 /* Check for mapped keys out of X11 function keys. */ 1827 for (i = 0; i < LEN(mappedkeys); i++) { 1828 if (mappedkeys[i] == k) 1829 break; 1830 } 1831 if (i == LEN(mappedkeys)) { 1832 if ((k & 0xFFFF) < 0xFD00) 1833 return NULL; 1834 } 1835 1836 for (kp = key; kp < key + LEN(key); kp++) { 1837 if (kp->k != k) 1838 continue; 1839 1840 if (!match(kp->mask, state)) 1841 continue; 1842 1843 if (IS_SET(MODE_APPKEYPAD) ? kp->appkey < 0 : kp->appkey > 0) 1844 continue; 1845 if (IS_SET(MODE_NUMLOCK) && kp->appkey == 2) 1846 continue; 1847 1848 if (IS_SET(MODE_APPCURSOR) ? kp->appcursor < 0 : kp->appcursor > 0) 1849 continue; 1850 1851 return kp->s; 1852 } 1853 1854 return NULL; 1855 } 1856 1857 void 1858 kpress(XEvent *ev) 1859 { 1860 XKeyEvent *e = &ev->xkey; 1861 KeySym ksym = NoSymbol; 1862 char buf[64], *customkey; 1863 int len; 1864 Rune c; 1865 Status status; 1866 Shortcut *bp; 1867 1868 if (IS_SET(MODE_KBDLOCK)) 1869 return; 1870 1871 if (xw.ime.xic) { 1872 len = XmbLookupString(xw.ime.xic, e, buf, sizeof buf, &ksym, &status); 1873 if (status == XBufferOverflow) 1874 return; 1875 } else { 1876 len = XLookupString(e, buf, sizeof buf, &ksym, NULL); 1877 } 1878 /* 1. shortcuts */ 1879 for (bp = shortcuts; bp < shortcuts + LEN(shortcuts); bp++) { 1880 if (ksym == bp->keysym && match(bp->mod, e->state)) { 1881 bp->func(&(bp->arg)); 1882 return; 1883 } 1884 } 1885 1886 /* 2. custom keys from config.h */ 1887 if ((customkey = kmap(ksym, e->state))) { 1888 ttywrite(customkey, strlen(customkey), 1); 1889 return; 1890 } 1891 1892 /* 3. composed string from input method */ 1893 if (len == 0) 1894 return; 1895 if (len == 1 && e->state & Mod1Mask) { 1896 if (IS_SET(MODE_8BIT)) { 1897 if (*buf < 0177) { 1898 c = *buf | 0x80; 1899 len = utf8encode(c, buf); 1900 } 1901 } else { 1902 buf[1] = buf[0]; 1903 buf[0] = '\033'; 1904 len = 2; 1905 } 1906 } 1907 ttywrite(buf, len, 1); 1908 } 1909 1910 void 1911 cmessage(XEvent *e) 1912 { 1913 /* 1914 * See xembed specs 1915 * http://standards.freedesktop.org/xembed-spec/xembed-spec-latest.html 1916 */ 1917 if (e->xclient.message_type == xw.xembed && e->xclient.format == 32) { 1918 if (e->xclient.data.l[1] == XEMBED_FOCUS_IN) { 1919 win.mode |= MODE_FOCUSED; 1920 xseturgency(0); 1921 } else if (e->xclient.data.l[1] == XEMBED_FOCUS_OUT) { 1922 win.mode &= ~MODE_FOCUSED; 1923 } 1924 } else if (e->xclient.data.l[0] == xw.wmdeletewin) { 1925 ttyhangup(); 1926 exit(0); 1927 } 1928 } 1929 1930 void 1931 resize(XEvent *e) 1932 { 1933 if (e->xconfigure.width == win.w && e->xconfigure.height == win.h) 1934 return; 1935 1936 cresize(e->xconfigure.width, e->xconfigure.height); 1937 } 1938 1939 void 1940 run(void) 1941 { 1942 XEvent ev; 1943 int w = win.w, h = win.h; 1944 fd_set rfd; 1945 int xfd = XConnectionNumber(xw.dpy), ttyfd, xev, drawing; 1946 struct timespec seltv, *tv, now, lastblink, trigger; 1947 double timeout; 1948 1949 /* Waiting for window mapping */ 1950 do { 1951 XNextEvent(xw.dpy, &ev); 1952 /* 1953 * This XFilterEvent call is required because of XOpenIM. It 1954 * does filter out the key event and some client message for 1955 * the input method too. 1956 */ 1957 if (XFilterEvent(&ev, None)) 1958 continue; 1959 if (ev.type == ConfigureNotify) { 1960 w = ev.xconfigure.width; 1961 h = ev.xconfigure.height; 1962 } 1963 } while (ev.type != MapNotify); 1964 1965 ttyfd = ttynew(opt_line, shell, opt_io, opt_cmd); 1966 cresize(w, h); 1967 1968 for (timeout = -1, drawing = 0, lastblink = (struct timespec){0};;) { 1969 FD_ZERO(&rfd); 1970 FD_SET(ttyfd, &rfd); 1971 FD_SET(xfd, &rfd); 1972 1973 if (XPending(xw.dpy)) 1974 timeout = 0; /* existing events might not set xfd */ 1975 1976 seltv.tv_sec = timeout / 1E3; 1977 seltv.tv_nsec = 1E6 * (timeout - 1E3 * seltv.tv_sec); 1978 tv = timeout >= 0 ? &seltv : NULL; 1979 1980 if (pselect(MAX(xfd, ttyfd)+1, &rfd, NULL, NULL, tv, NULL) < 0) { 1981 if (errno == EINTR) 1982 continue; 1983 die("select failed: %s\n", strerror(errno)); 1984 } 1985 clock_gettime(CLOCK_MONOTONIC, &now); 1986 1987 if (FD_ISSET(ttyfd, &rfd)) 1988 ttyread(); 1989 1990 xev = 0; 1991 while (XPending(xw.dpy)) { 1992 xev = 1; 1993 XNextEvent(xw.dpy, &ev); 1994 if (XFilterEvent(&ev, None)) 1995 continue; 1996 if (handler[ev.type]) 1997 (handler[ev.type])(&ev); 1998 } 1999 2000 /* 2001 * To reduce flicker and tearing, when new content or event 2002 * triggers drawing, we first wait a bit to ensure we got 2003 * everything, and if nothing new arrives - we draw. 2004 * We start with trying to wait minlatency ms. If more content 2005 * arrives sooner, we retry with shorter and shorter periods, 2006 * and eventually draw even without idle after maxlatency ms. 2007 * Typically this results in low latency while interacting, 2008 * maximum latency intervals during `cat huge.txt`, and perfect 2009 * sync with periodic updates from animations/key-repeats/etc. 2010 */ 2011 if (FD_ISSET(ttyfd, &rfd) || xev) { 2012 if (!drawing) { 2013 trigger = now; 2014 drawing = 1; 2015 } 2016 timeout = (maxlatency - TIMEDIFF(now, trigger)) \ 2017 / maxlatency * minlatency; 2018 if (timeout > 0) 2019 continue; /* we have time, try to find idle */ 2020 } 2021 2022 /* idle detected or maxlatency exhausted -> draw */ 2023 timeout = -1; 2024 if (blinktimeout && tattrset(ATTR_BLINK)) { 2025 timeout = blinktimeout - TIMEDIFF(now, lastblink); 2026 if (timeout <= 0) { 2027 if (-timeout > blinktimeout) /* start visible */ 2028 win.mode |= MODE_BLINK; 2029 win.mode ^= MODE_BLINK; 2030 tsetdirtattr(ATTR_BLINK); 2031 lastblink = now; 2032 timeout = blinktimeout; 2033 } 2034 } 2035 2036 draw(); 2037 XFlush(xw.dpy); 2038 drawing = 0; 2039 } 2040 } 2041 2042 void 2043 usage(void) 2044 { 2045 die("usage: %s [-aiv] [-c class] [-f font] [-g geometry]" 2046 " [-n name] [-o file]\n" 2047 " [-T title] [-t title] [-w windowid]" 2048 " [[-e] command [args ...]]\n" , argv0, argv0); 2049 } 2050 2051 int 2052 main(int argc, char *argv[]) 2053 { 2054 xw.l = xw.t = 0; 2055 xw.isfixed = False; 2056 xsetcursor(cursorshape); 2057 2058 ARGBEGIN { 2059 case 'a': 2060 allowaltscreen = 0; 2061 break; 2062 case 'c': 2063 opt_class = EARGF(usage()); 2064 break; 2065 case 'e': 2066 if (argc > 0) 2067 --argc, ++argv; 2068 goto run; 2069 case 'f': 2070 opt_font = EARGF(usage()); 2071 break; 2072 case 'g': 2073 xw.gm = XParseGeometry(EARGF(usage()), 2074 &xw.l, &xw.t, &cols, &rows); 2075 break; 2076 case 'i': 2077 xw.isfixed = 1; 2078 break; 2079 case 'o': 2080 opt_io = EARGF(usage()); 2081 break; 2082 case 'l': 2083 opt_line = EARGF(usage()); 2084 break; 2085 case 'n': 2086 opt_name = EARGF(usage()); 2087 break; 2088 case 't': 2089 case 'T': 2090 opt_title = EARGF(usage()); 2091 break; 2092 case 'w': 2093 opt_embed = EARGF(usage()); 2094 break; 2095 case 'v': 2096 die("%s " VERSION "\n", argv0); 2097 break; 2098 default: 2099 usage(); 2100 } ARGEND; 2101 2102 run: 2103 if (argc > 0) /* eat all remaining arguments */ 2104 opt_cmd = argv; 2105 2106 if (!opt_title) 2107 opt_title = (opt_line || !opt_cmd) ? "st" : opt_cmd[0]; 2108 2109 setlocale(LC_CTYPE, ""); 2110 XSetLocaleModifiers(""); 2111 cols = MAX(cols, 1); 2112 rows = MAX(rows, 1); 2113 tnew(cols, rows); 2114 xinit(cols, rows); 2115 xsetenv(); 2116 selinit(); 2117 run(); 2118 2119 return 0; 2120 }