From 2b591735eae0d38e5a09d3bc52dc4aea32ddc7fc Mon Sep 17 00:00:00 2001 From: Bazsi <66674037+nagbalae@users.noreply.github.com> Date: Sun, 9 Jan 2022 11:30:37 +0000 Subject: [PATCH] Add files via upload --- Makefile | 64 ++ PKGBUILD | 45 + README.md | 74 ++ arg.h | 50 + boxdraw.c | 194 ++++ boxdraw.o | Bin 0 -> 7728 bytes boxdraw_data.h | 214 ++++ config.h | 562 ++++++++++ config.mk | 39 + st-copyout | 13 + st-urlhandler | 15 + st.1 | 194 ++++ st.c | 2780 ++++++++++++++++++++++++++++++++++++++++++++++++ st.h | 147 +++ st.info | 222 ++++ st.o | Bin 0 -> 80056 bytes win.h | 40 + x.c | 2208 ++++++++++++++++++++++++++++++++++++++ x.o | Bin 0 -> 87192 bytes 19 files changed, 6861 insertions(+) create mode 100644 Makefile create mode 100644 PKGBUILD create mode 100644 README.md create mode 100644 arg.h create mode 100644 boxdraw.c create mode 100644 boxdraw.o create mode 100644 boxdraw_data.h create mode 100644 config.h create mode 100644 config.mk create mode 100644 st-copyout create mode 100644 st-urlhandler create mode 100644 st.1 create mode 100644 st.c create mode 100644 st.h create mode 100644 st.info create mode 100644 st.o create mode 100644 win.h create mode 100644 x.c create mode 100644 x.o diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..2e05e4b --- /dev/null +++ b/Makefile @@ -0,0 +1,64 @@ +# st - simple terminal +# See LICENSE file for copyright and license details. +.POSIX: + +include config.mk + +SRC = st.c x.c boxdraw.c +OBJ = $(SRC:.c=.o) + +all: options st + +options: + @echo st build options: + @echo "CFLAGS = $(STCFLAGS)" + @echo "LDFLAGS = $(STLDFLAGS)" + @echo "CC = $(CC)" + +config.h: + cp config.def.h config.h + +.c.o: + $(CC) $(STCFLAGS) -c $< + +st.o: config.h st.h win.h +x.o: arg.h config.h st.h win.h +boxdraw.o: config.h st.h boxdraw_data.h + +$(OBJ): config.h config.mk + +st: $(OBJ) + $(CC) -o $@ $(OBJ) $(STLDFLAGS) + +clean: + rm -f st $(OBJ) st-$(VERSION).tar.gz *.o *.orig *.rej + +dist: clean + mkdir -p st-$(VERSION) + cp -R FAQ LEGACY TODO LICENSE Makefile README config.mk\ + config.def.h st.info st.1 arg.h st.h win.h $(SRC)\ + st-$(VERSION) + tar -cf - st-$(VERSION) | gzip > st-$(VERSION).tar.gz + rm -rf st-$(VERSION) + +install: st + mkdir -p $(DESTDIR)$(PREFIX)/bin + cp -f st $(DESTDIR)$(PREFIX)/bin + cp -f st-copyout $(DESTDIR)$(PREFIX)/bin + cp -f st-urlhandler $(DESTDIR)$(PREFIX)/bin + chmod 755 $(DESTDIR)$(PREFIX)/bin/st + chmod 755 $(DESTDIR)$(PREFIX)/bin/st-copyout + chmod 755 $(DESTDIR)$(PREFIX)/bin/st-urlhandler + mkdir -p $(DESTDIR)$(MANPREFIX)/man1 + sed "s/VERSION/$(VERSION)/g" < st.1 > $(DESTDIR)$(MANPREFIX)/man1/st.1 + chmod 644 $(DESTDIR)$(MANPREFIX)/man1/st.1 + tic -sx st.info + @echo Please see the README file regarding the terminfo entry of st. + +uninstall: + rm -f $(DESTDIR)$(PREFIX)/bin/st + rm -f $(DESTDIR)$(PREFIX)/bin/st-copyout + rm -f $(DESTDIR)$(PREFIX)/bin/st-urlhandler + rm -f $(DESTDIR)$(MANPREFIX)/man1/st.1 + +.PHONY: all options clean dist install uninstall diff --git a/PKGBUILD b/PKGBUILD new file mode 100644 index 0000000..98a057d --- /dev/null +++ b/PKGBUILD @@ -0,0 +1,45 @@ +# Maintainer: + +pkgname=st-luke-git +_pkgname=st +pkgver=0.8.2.r1062.2087ab9 +pkgrel=1 +epoch=1 +pkgdesc="Luke's simple (suckless) terminal with vim-bindings, transparency, xresources, etc. " +url='https://github.com/LukeSmithxyz/st' +arch=('i686' 'x86_64') +license=('MIT') +options=('zipman') +depends=('libxft') +makedepends=('ncurses' 'libxext' 'git') +optdepends=('dmenu: feed urls to dmenu') +source=('git://github.com/LukeSmithxyz/st') +sha1sums=('SKIP') + +provides=("${_pkgname}") +conflicts=("${_pkgname}") + +pkgver() { + cd "${_pkgname}" + printf "%s.r%s.%s" "$(awk '/^VERSION =/ {print $3}' config.mk)" \ + "$(git rev-list --count HEAD)" "$(git rev-parse --short HEAD)" +} + +prepare() { + cd $srcdir/${_pkgname} + # skip terminfo which conflicts with ncurses + sed -i '/tic /d' Makefile +} + +build() { + cd "${_pkgname}" + make X11INC=/usr/include/X11 X11LIB=/usr/lib/X11 +} + +package() { + cd "${_pkgname}" + make PREFIX=/usr DESTDIR="${pkgdir}" install + install -Dm644 LICENSE "${pkgdir}/usr/share/licenses/${pkgname}/LICENSE" + install -Dm644 README.md "${pkgdir}/usr/share/doc/${pkgname}/README.md" + install -Dm644 .Xdefaults "${pkgdir}/usr/share/doc/${pkgname}/Xdefaults.example" +} diff --git a/README.md b/README.md new file mode 100644 index 0000000..34ea94d --- /dev/null +++ b/README.md @@ -0,0 +1,74 @@ +# nagbalae's build of st from Luke's - the simple (suckless) terminal + +The [suckless terminal (st)](https://st.suckless.org/) with some additional features that make it literally the best terminal emulator ever: + +## Unique features (using dmenu) + ++ **follow urls** by pressing `alt-l` ++ **copy urls** in the same way with `alt-y` ++ **copy the output of commands** with `alt-o` + +## Bindings for + ++ **scrollback** with `alt-↑/↓` or `alt-pageup/down` or `shift` while scrolling the mouse ++ OR **vim-bindings**: scroll up/down in history with `alt-k` and `alt-j`. Faster with `alt-u`/`alt-d`. ++ **zoom/change font size**: same bindings as above, but holding down shift as well. `alt-home` returns to default ++ **copy text** with `alt-c`, **paste** is `alt-v` or `shift-insert` + +## Pretty stuff + ++ Compatibility with `Xresources` and `pywal` for dynamic colors. ++ Default [gruvbox](https://github.com/morhetz/gruvbox) colors otherwise. ++ Transparency/alpha, which is also adjustable from your `Xresources`. ++ Default font is system "mono" at 14pt, meaning the font will match your system font. + +## Other st patches + ++ Vertcenter ++ Scrollback ++ font2 ++ updated to latest version 0.8.2 + +## Installation for newbs + +``` +sudo make install +``` + + +Obviously, `make` is required to build. `fontconfig` is required for the default build, since it asks `fontconfig` for your system monospace font. It might be obvious, but `libX11` and `libXft` are required as well. Chances are, you have all of this installed already. + +On OpenBSD, be sure to edit `config.mk` first and remove `-lrt` from the `$LIBS` before compiling. + +Be sure to have a composite manager (`xcompmgr`, `picom`, etc.) running if you want transparency. + +## How to configure dynamically with Xresources + +For many key variables, this build of `st` will look for X settings set in either `~/.Xdefaults` or `~/.Xresources`. You must run `xrdb` on one of these files to load the settings. + +For example, you can define your desired fonts, transparency or colors: + +``` +*.font: Liberation Mono:pixelsize=12:antialias=true:autohint=true; +*.alpha: 0.9 +*.color0: #111 +... +``` + +The `alpha` value (for transparency) goes from `0` (transparent) to `1` (opaque). + +### Colors + +To be clear about the color settings: + +- This build will use gruvbox colors by default and as a fallback. +- If there are Xresources colors defined, those will take priority. +- But if `wal` has run in your session, its colors will take priority. + +Note that when you run `wal`, it will negate the transparency of existing windows, but new windows will continue with the previously defined transparency. + +## Notes on Emojis and Special Characters + +If st crashes when viewing emojis, install [libxft-bgra](https://aur.archlinux.org/packages/libxft-bgra/) from the AUR. + +Note that some special characters may appear truncated if too wide. You might want to manually set your prefered emoji/special character font to a lower size in the `config.h` file to avoid this. By default, JoyPixels is used at a smaller size than the usual text. diff --git a/arg.h b/arg.h new file mode 100644 index 0000000..a22e019 --- /dev/null +++ b/arg.h @@ -0,0 +1,50 @@ +/* + * Copy me if you can. + * by 20h + */ + +#ifndef ARG_H__ +#define ARG_H__ + +extern char *argv0; + +/* use main(int argc, char *argv[]) */ +#define ARGBEGIN for (argv0 = *argv, argv++, argc--;\ + argv[0] && argv[0][0] == '-'\ + && argv[0][1];\ + argc--, argv++) {\ + char argc_;\ + char **argv_;\ + int brk_;\ + if (argv[0][1] == '-' && argv[0][2] == '\0') {\ + argv++;\ + argc--;\ + break;\ + }\ + int i_;\ + for (i_ = 1, brk_ = 0, argv_ = argv;\ + argv[0][i_] && !brk_;\ + i_++) {\ + if (argv_ != argv)\ + break;\ + argc_ = argv[0][i_];\ + switch (argc_) + +#define ARGEND }\ + } + +#define ARGC() argc_ + +#define EARGF(x) ((argv[0][i_+1] == '\0' && argv[1] == NULL)?\ + ((x), abort(), (char *)0) :\ + (brk_ = 1, (argv[0][i_+1] != '\0')?\ + (&argv[0][i_+1]) :\ + (argc--, argv++, argv[0]))) + +#define ARGF() ((argv[0][i_+1] == '\0' && argv[1] == NULL)?\ + (char *)0 :\ + (brk_ = 1, (argv[0][i_+1] != '\0')?\ + (&argv[0][i_+1]) :\ + (argc--, argv++, argv[0]))) + +#endif diff --git a/boxdraw.c b/boxdraw.c new file mode 100644 index 0000000..28a92d0 --- /dev/null +++ b/boxdraw.c @@ -0,0 +1,194 @@ +/* + * Copyright 2018 Avi Halachmi (:avih) avihpit@yahoo.com https://github.com/avih + * MIT/X Consortium License + */ + +#include +#include "st.h" +#include "boxdraw_data.h" + +/* Rounded non-negative integers division of n / d */ +#define DIV(n, d) (((n) + (d) / 2) / (d)) + +static Display *xdpy; +static Colormap xcmap; +static XftDraw *xd; +static Visual *xvis; + +static void drawbox(int, int, int, int, XftColor *, XftColor *, ushort); +static void drawboxlines(int, int, int, int, XftColor *, ushort); + +/* public API */ + +void +boxdraw_xinit(Display *dpy, Colormap cmap, XftDraw *draw, Visual *vis) +{ + xdpy = dpy; xcmap = cmap; xd = draw, xvis = vis; +} + +int +isboxdraw(Rune u) +{ + Rune block = u & ~0xff; + return (boxdraw && block == 0x2500 && boxdata[(uint8_t)u]) || + (boxdraw_braille && block == 0x2800); +} + +/* the "index" is actually the entire shape data encoded as ushort */ +ushort +boxdrawindex(const Glyph *g) +{ + if (boxdraw_braille && (g->u & ~0xff) == 0x2800) + return BRL | (uint8_t)g->u; + if (boxdraw_bold && (g->mode & ATTR_BOLD)) + return BDB | boxdata[(uint8_t)g->u]; + return boxdata[(uint8_t)g->u]; +} + +void +drawboxes(int x, int y, int cw, int ch, XftColor *fg, XftColor *bg, + const XftGlyphFontSpec *specs, int len) +{ + for ( ; len-- > 0; x += cw, specs++) + drawbox(x, y, cw, ch, fg, bg, (ushort)specs->glyph); +} + +/* implementation */ + +void +drawbox(int x, int y, int w, int h, XftColor *fg, XftColor *bg, ushort bd) +{ + ushort cat = bd & ~(BDB | 0xff); /* mask out bold and data */ + if (bd & (BDL | BDA)) { + /* lines (light/double/heavy/arcs) */ + drawboxlines(x, y, w, h, fg, bd); + + } else if (cat == BBD) { + /* lower (8-X)/8 block */ + int d = DIV((uint8_t)bd * h, 8); + XftDrawRect(xd, fg, x, y + d, w, h - d); + + } else if (cat == BBU) { + /* upper X/8 block */ + XftDrawRect(xd, fg, x, y, w, DIV((uint8_t)bd * h, 8)); + + } else if (cat == BBL) { + /* left X/8 block */ + XftDrawRect(xd, fg, x, y, DIV((uint8_t)bd * w, 8), h); + + } else if (cat == BBR) { + /* right (8-X)/8 block */ + int d = DIV((uint8_t)bd * w, 8); + XftDrawRect(xd, fg, x + d, y, w - d, h); + + } else if (cat == BBQ) { + /* Quadrants */ + int w2 = DIV(w, 2), h2 = DIV(h, 2); + if (bd & TL) + XftDrawRect(xd, fg, x, y, w2, h2); + if (bd & TR) + XftDrawRect(xd, fg, x + w2, y, w - w2, h2); + if (bd & BL) + XftDrawRect(xd, fg, x, y + h2, w2, h - h2); + if (bd & BR) + XftDrawRect(xd, fg, x + w2, y + h2, w - w2, h - h2); + + } else if (bd & BBS) { + /* Shades - data is 1/2/3 for 25%/50%/75% alpha, respectively */ + int d = (uint8_t)bd; + XftColor xfc; + XRenderColor xrc = { .alpha = 0xffff }; + + xrc.red = DIV(fg->color.red * d + bg->color.red * (4 - d), 4); + xrc.green = DIV(fg->color.green * d + bg->color.green * (4 - d), 4); + xrc.blue = DIV(fg->color.blue * d + bg->color.blue * (4 - d), 4); + + XftColorAllocValue(xdpy, xvis, xcmap, &xrc, &xfc); + XftDrawRect(xd, &xfc, x, y, w, h); + XftColorFree(xdpy, xvis, xcmap, &xfc); + + } else if (cat == BRL) { + /* braille, each data bit corresponds to one dot at 2x4 grid */ + int w1 = DIV(w, 2); + int h1 = DIV(h, 4), h2 = DIV(h, 2), h3 = DIV(3 * h, 4); + + if (bd & 1) XftDrawRect(xd, fg, x, y, w1, h1); + if (bd & 2) XftDrawRect(xd, fg, x, y + h1, w1, h2 - h1); + if (bd & 4) XftDrawRect(xd, fg, x, y + h2, w1, h3 - h2); + if (bd & 8) XftDrawRect(xd, fg, x + w1, y, w - w1, h1); + if (bd & 16) XftDrawRect(xd, fg, x + w1, y + h1, w - w1, h2 - h1); + if (bd & 32) XftDrawRect(xd, fg, x + w1, y + h2, w - w1, h3 - h2); + if (bd & 64) XftDrawRect(xd, fg, x, y + h3, w1, h - h3); + if (bd & 128) XftDrawRect(xd, fg, x + w1, y + h3, w - w1, h - h3); + + } +} + +void +drawboxlines(int x, int y, int w, int h, XftColor *fg, ushort bd) +{ + /* s: stem thickness. width/8 roughly matches underscore thickness. */ + /* We draw bold as 1.5 * normal-stem and at least 1px thicker. */ + /* doubles draw at least 3px, even when w or h < 3. bold needs 6px. */ + int mwh = MIN(w, h); + int base_s = MAX(1, DIV(mwh, 8)); + int bold = (bd & BDB) && mwh >= 6; /* possibly ignore boldness */ + int s = bold ? MAX(base_s + 1, DIV(3 * base_s, 2)) : base_s; + int w2 = DIV(w - s, 2), h2 = DIV(h - s, 2); + /* the s-by-s square (x + w2, y + h2, s, s) is the center texel. */ + /* The base length (per direction till edge) includes this square. */ + + int light = bd & (LL | LU | LR | LD); + int double_ = bd & (DL | DU | DR | DD); + + if (light) { + /* d: additional (negative) length to not-draw the center */ + /* texel - at arcs and avoid drawing inside (some) doubles */ + int arc = bd & BDA; + int multi_light = light & (light - 1); + int multi_double = double_ & (double_ - 1); + /* light crosses double only at DH+LV, DV+LH (ref. shapes) */ + int d = arc || (multi_double && !multi_light) ? -s : 0; + + if (bd & LL) + XftDrawRect(xd, fg, x, y + h2, w2 + s + d, s); + if (bd & LU) + XftDrawRect(xd, fg, x + w2, y, s, h2 + s + d); + if (bd & LR) + XftDrawRect(xd, fg, x + w2 - d, y + h2, w - w2 + d, s); + if (bd & LD) + XftDrawRect(xd, fg, x + w2, y + h2 - d, s, h - h2 + d); + } + + /* double lines - also align with light to form heavy when combined */ + if (double_) { + /* + * going clockwise, for each double-ray: p is additional length + * to the single-ray nearer to the previous direction, and n to + * the next. p and n adjust from the base length to lengths + * which consider other doubles - shorter to avoid intersections + * (p, n), or longer to draw the far-corner texel (n). + */ + int dl = bd & DL, du = bd & DU, dr = bd & DR, dd = bd & DD; + if (dl) { + int p = dd ? -s : 0, n = du ? -s : dd ? s : 0; + XftDrawRect(xd, fg, x, y + h2 + s, w2 + s + p, s); + XftDrawRect(xd, fg, x, y + h2 - s, w2 + s + n, s); + } + if (du) { + int p = dl ? -s : 0, n = dr ? -s : dl ? s : 0; + XftDrawRect(xd, fg, x + w2 - s, y, s, h2 + s + p); + XftDrawRect(xd, fg, x + w2 + s, y, s, h2 + s + n); + } + if (dr) { + int p = du ? -s : 0, n = dd ? -s : du ? s : 0; + XftDrawRect(xd, fg, x + w2 - p, y + h2 - s, w - w2 + p, s); + XftDrawRect(xd, fg, x + w2 - n, y + h2 + s, w - w2 + n, s); + } + if (dd) { + int p = dr ? -s : 0, n = dl ? -s : dr ? s : 0; + XftDrawRect(xd, fg, x + w2 + s, y + h2 - p, s, h - h2 + p); + XftDrawRect(xd, fg, x + w2 - s, y + h2 - n, s, h - h2 + n); + } + } +} diff --git a/boxdraw.o b/boxdraw.o new file mode 100644 index 0000000000000000000000000000000000000000..3080fdc92aa26916aecfad85938e0fc9df48d565 GIT binary patch literal 7728 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 cursor */ + "#555555", /* 257 -> rev cursor*/ + "#282828", /* 258 -> bg */ + "#ebdbb2", /* 259 -> fg */ +}; + + +/* + * Default colors (colorname index) + * foreground, background, cursor, reverse cursor + */ +unsigned int defaultfg = 259; +unsigned int defaultbg = 258; +unsigned int defaultcs = 256; +unsigned int defaultrcs = 257; + +/* + * Default shape of cursor + * 2: Block ("█") + * 4: Underline ("_") + * 6: Bar ("|") + * 7: Snowman ("☃") + */ +static unsigned int cursorshape = 2; + +/* + * Default columns and rows numbers + */ + +static unsigned int cols = 80; +static unsigned int rows = 24; + +/* + * Default colour and shape of the mouse cursor + */ +static unsigned int mouseshape= XC_xterm; +static unsigned int mousefg = 7; +static unsigned int mousebg = 0; + +/* + * Color used to display font attributes when fontconfig selected a font which + * doesn't match the ones requested. + */ +static unsigned int defaultattr = 11; + +/* + * Xresources preferences to load at startup + */ +ResourcePref resources[] = { + { "font", STRING, &font }, + { "fontalt0", STRING, &font2[0] }, + { "color0", STRING, &colorname[0] }, + { "color1", STRING, &colorname[1] }, + { "color2", STRING, &colorname[2] }, + { "color3", STRING, &colorname[3] }, + { "color4", STRING, &colorname[4] }, + { "color5", STRING, &colorname[5] }, + { "color6", STRING, &colorname[6] }, + { "color7", STRING, &colorname[7] }, + { "color8", STRING, &colorname[8] }, + { "color9", STRING, &colorname[9] }, + { "color10", STRING, &colorname[10] }, + { "color11", STRING, &colorname[11] }, + { "color12", STRING, &colorname[12] }, + { "color13", STRING, &colorname[13] }, + { "color14", STRING, &colorname[14] }, + { "color15", STRING, &colorname[15] }, + { "background", STRING, &colorname[258] }, + { "foreground", STRING, &colorname[259] }, + { "cursorColor", STRING, &colorname[256] }, + { "termname", STRING, &termname }, + { "shell", STRING, &shell }, + { "blinktimeout", INTEGER, &blinktimeout }, + { "bellvolume", INTEGER, &bellvolume }, + { "tabspaces", INTEGER, &tabspaces }, + { "borderpx", INTEGER, &borderpx }, + { "cwscale", FLOAT, &cwscale }, + { "chscale", FLOAT, &chscale }, + { "alpha", FLOAT, &alpha }, + { "ximspot_update_interval", INTEGER, &ximspot_update_interval }, +}; + +/* + * Internal mouse shortcuts. + * Beware that overloading Button1 will disable the selection. + */ +static MouseShortcut mshortcuts[] = { + /* button mask string */ + { Button4, XK_NO_MOD, "\031" }, + { Button5, XK_NO_MOD, "\005" }, +}; + +/* Internal keyboard shortcuts. */ +#define MODKEY Mod1Mask +#define TERMMOD (Mod1Mask|ShiftMask) + +MouseKey mkeys[] = { + /* button mask function argument */ + { Button4, ShiftMask, kscrollup, {.i = 1} }, + { Button5, ShiftMask, kscrolldown, {.i = 1} }, + { Button4, MODKEY, kscrollup, {.i = 1} }, + { Button5, MODKEY, kscrolldown, {.i = 1} }, + { Button4, TERMMOD, zoom, {.f = +1} }, + { Button5, TERMMOD, zoom, {.f = -1} }, +}; + +static char *openurlcmd[] = { "/bin/sh", "-c", "st-urlhandler", "externalpipe", NULL }; + +static char *copyurlcmd[] = { "/bin/sh", "-c", + "tmp=$(sed 's/.*│//g' | tr -d '\n' | grep -aEo '(((http|https)://|www\\.)[a-zA-Z0-9.]*[:]?[a-zA-Z0-9./@$&%?$#=_-]*)|((magnet:\\?xt=urn:btih:)[a-zA-Z0-9]*)' | uniq | sed 's/^www./http:\\/\\/www\\./g' ); IFS=; [ ! -z $tmp ] && echo $tmp | dmenu -i -p 'Copy which url?' -l 10 | tr -d '\n' | xclip -selection clipboard", + "externalpipe", NULL }; + +static char *copyoutput[] = { "/bin/sh", "-c", "st-copyout", "externalpipe", NULL }; + +static Shortcut shortcuts[] = { + /* mask keysym function argument */ + { XK_ANY_MOD, XK_Break, sendbreak, {.i = 0} }, + { ControlMask, XK_Print, toggleprinter, {.i = 0} }, + { ShiftMask, XK_Print, printscreen, {.i = 0} }, + { XK_ANY_MOD, XK_Print, printsel, {.i = 0} }, + { TERMMOD, XK_Prior, zoom, {.f = +1} }, + { TERMMOD, XK_Next, zoom, {.f = -1} }, + { MODKEY, XK_Home, zoomreset, {.f = 0} }, + { MODKEY, XK_c, clipcopy, {.i = 0} }, + { ShiftMask, XK_Insert, clippaste, {.i = 0} }, + { MODKEY, XK_v, clippaste, {.i = 0} }, + { XK_ANY_MOD, Button2, selpaste, {.i = 0} }, + { MODKEY, XK_Num_Lock, numlock, {.i = 0} }, + { MODKEY, XK_Control_L, iso14755, {.i = 0} }, + { ShiftMask, XK_Page_Up, kscrollup, {.i = -1} }, + { ShiftMask, XK_Page_Down, kscrolldown, {.i = -1} }, + { MODKEY, XK_Page_Up, kscrollup, {.i = -1} }, + { MODKEY, XK_Page_Down, kscrolldown, {.i = -1} }, + { MODKEY, XK_k, kscrollup, {.i = 1} }, + { MODKEY, XK_j, kscrolldown, {.i = 1} }, + { MODKEY, XK_Up, kscrollup, {.i = 1} }, + { MODKEY, XK_Down, kscrolldown, {.i = 1} }, + { MODKEY, XK_u, kscrollup, {.i = -1} }, + { MODKEY, XK_d, kscrolldown, {.i = -1} }, + { TERMMOD, XK_Up, zoom, {.f = +1} }, + { TERMMOD, XK_Down, zoom, {.f = -1} }, + { TERMMOD, XK_K, zoom, {.f = +1} }, + { TERMMOD, XK_J, zoom, {.f = -1} }, + { TERMMOD, XK_U, zoom, {.f = +2} }, + { TERMMOD, XK_D, zoom, {.f = -2} }, + { MODKEY, XK_l, externalpipe, {.v = openurlcmd } }, + { MODKEY, XK_y, externalpipe, {.v = copyurlcmd } }, + { MODKEY, XK_o, externalpipe, {.v = copyoutput } }, +}; + +/* + * Special keys (change & recompile st.info accordingly) + * + * Mask value: + * * Use XK_ANY_MOD to match the key no matter modifiers state + * * Use XK_NO_MOD to match the key alone (no modifiers) + * appkey value: + * * 0: no value + * * > 0: keypad application mode enabled + * * = 2: term.numlock = 1 + * * < 0: keypad application mode disabled + * appcursor value: + * * 0: no value + * * > 0: cursor application mode enabled + * * < 0: cursor application mode disabled + * crlf value + * * 0: no value + * * > 0: crlf mode is enabled + * * < 0: crlf mode is disabled + * + * Be careful with the order of the definitions because st searches in + * this table sequentially, so any XK_ANY_MOD must be in the last + * position for a key. + */ + +/* + * If you want keys other than the X11 function keys (0xFD00 - 0xFFFF) + * to be mapped below, add them to this array. + */ +static KeySym mappedkeys[] = { -1 }; + +/* + * State bits to ignore when matching key or button events. By default, + * numlock (Mod2Mask) and keyboard layout (XK_SWITCH_MOD) are ignored. + */ +static uint ignoremod = Mod2Mask|XK_SWITCH_MOD; + +/* + * Override mouse-select while mask is active (when MODE_MOUSE is set). + * Note that if you want to use ShiftMask with selmasks, set this to an other + * modifier, set to 0 to not use it. + */ +static uint forceselmod = ShiftMask; + +/* + * This is the huge key array which defines all compatibility to the Linux + * world. Please decide about changes wisely. + */ +static Key key[] = { + /* keysym mask string appkey appcursor */ + { XK_KP_Home, ShiftMask, "\033[2J", 0, -1}, + { XK_KP_Home, ShiftMask, "\033[1;2H", 0, +1}, + { XK_KP_Home, XK_ANY_MOD, "\033[H", 0, -1}, + { XK_KP_Home, XK_ANY_MOD, "\033[1~", 0, +1}, + { XK_KP_Up, XK_ANY_MOD, "\033Ox", +1, 0}, + { XK_KP_Up, XK_ANY_MOD, "\033[A", 0, -1}, + { XK_KP_Up, XK_ANY_MOD, "\033OA", 0, +1}, + { XK_KP_Down, XK_ANY_MOD, "\033Or", +1, 0}, + { XK_KP_Down, XK_ANY_MOD, "\033[B", 0, -1}, + { XK_KP_Down, XK_ANY_MOD, "\033OB", 0, +1}, + { XK_KP_Left, XK_ANY_MOD, "\033Ot", +1, 0}, + { XK_KP_Left, XK_ANY_MOD, "\033[D", 0, -1}, + { XK_KP_Left, XK_ANY_MOD, "\033OD", 0, +1}, + { XK_KP_Right, XK_ANY_MOD, "\033Ov", +1, 0}, + { XK_KP_Right, XK_ANY_MOD, "\033[C", 0, -1}, + { XK_KP_Right, XK_ANY_MOD, "\033OC", 0, +1}, + { XK_KP_Prior, ShiftMask, "\033[5;2~", 0, 0}, + { XK_KP_Prior, XK_ANY_MOD, "\033[5~", 0, 0}, + { XK_KP_Begin, XK_ANY_MOD, "\033[E", 0, 0}, + { XK_KP_End, ControlMask, "\033[J", -1, 0}, + { XK_KP_End, ControlMask, "\033[1;5F", +1, 0}, + { XK_KP_End, ShiftMask, "\033[K", -1, 0}, + { XK_KP_End, ShiftMask, "\033[1;2F", +1, 0}, + { XK_KP_End, XK_ANY_MOD, "\033[4~", 0, 0}, + { XK_KP_Next, ShiftMask, "\033[6;2~", 0, 0}, + { XK_KP_Next, XK_ANY_MOD, "\033[6~", 0, 0}, + { XK_KP_Insert, ShiftMask, "\033[2;2~", +1, 0}, + { XK_KP_Insert, ShiftMask, "\033[4l", -1, 0}, + { XK_KP_Insert, ControlMask, "\033[L", -1, 0}, + { XK_KP_Insert, ControlMask, "\033[2;5~", +1, 0}, + { XK_KP_Insert, XK_ANY_MOD, "\033[4h", -1, 0}, + { XK_KP_Insert, XK_ANY_MOD, "\033[2~", +1, 0}, + { XK_KP_Delete, ControlMask, "\033[M", -1, 0}, + { XK_KP_Delete, ControlMask, "\033[3;5~", +1, 0}, + { XK_KP_Delete, ShiftMask, "\033[2K", -1, 0}, + { XK_KP_Delete, ShiftMask, "\033[3;2~", +1, 0}, + { XK_KP_Delete, XK_ANY_MOD, "\033[P", -1, 0}, + { XK_KP_Delete, XK_ANY_MOD, "\033[3~", +1, 0}, + { XK_KP_Multiply, XK_ANY_MOD, "\033Oj", +2, 0}, + { XK_KP_Add, XK_ANY_MOD, "\033Ok", +2, 0}, + { XK_KP_Enter, XK_ANY_MOD, "\033OM", +2, 0}, + { XK_KP_Enter, XK_ANY_MOD, "\r", -1, 0}, + { XK_KP_Subtract, XK_ANY_MOD, "\033Om", +2, 0}, + { XK_KP_Decimal, XK_ANY_MOD, "\033On", +2, 0}, + { XK_KP_Divide, XK_ANY_MOD, "\033Oo", +2, 0}, + { XK_KP_0, XK_ANY_MOD, "\033Op", +2, 0}, + { XK_KP_1, XK_ANY_MOD, "\033Oq", +2, 0}, + { XK_KP_2, XK_ANY_MOD, "\033Or", +2, 0}, + { XK_KP_3, XK_ANY_MOD, "\033Os", +2, 0}, + { XK_KP_4, XK_ANY_MOD, "\033Ot", +2, 0}, + { XK_KP_5, XK_ANY_MOD, "\033Ou", +2, 0}, + { XK_KP_6, XK_ANY_MOD, "\033Ov", +2, 0}, + { XK_KP_7, XK_ANY_MOD, "\033Ow", +2, 0}, + { XK_KP_8, XK_ANY_MOD, "\033Ox", +2, 0}, + { XK_KP_9, XK_ANY_MOD, "\033Oy", +2, 0}, + { XK_Up, ShiftMask, "\033[1;2A", 0, 0}, + { XK_Up, Mod1Mask, "\033[1;3A", 0, 0}, + { XK_Up, ShiftMask|Mod1Mask,"\033[1;4A", 0, 0}, + { XK_Up, ControlMask, "\033[1;5A", 0, 0}, + { XK_Up, ShiftMask|ControlMask,"\033[1;6A", 0, 0}, + { XK_Up, ControlMask|Mod1Mask,"\033[1;7A", 0, 0}, + { XK_Up,ShiftMask|ControlMask|Mod1Mask,"\033[1;8A", 0, 0}, + { XK_Up, XK_ANY_MOD, "\033[A", 0, -1}, + { XK_Up, XK_ANY_MOD, "\033OA", 0, +1}, + { XK_Down, ShiftMask, "\033[1;2B", 0, 0}, + { XK_Down, Mod1Mask, "\033[1;3B", 0, 0}, + { XK_Down, ShiftMask|Mod1Mask,"\033[1;4B", 0, 0}, + { XK_Down, ControlMask, "\033[1;5B", 0, 0}, + { XK_Down, ShiftMask|ControlMask,"\033[1;6B", 0, 0}, + { XK_Down, ControlMask|Mod1Mask,"\033[1;7B", 0, 0}, + { XK_Down,ShiftMask|ControlMask|Mod1Mask,"\033[1;8B",0, 0}, + { XK_Down, XK_ANY_MOD, "\033[B", 0, -1}, + { XK_Down, XK_ANY_MOD, "\033OB", 0, +1}, + { XK_Left, ShiftMask, "\033[1;2D", 0, 0}, + { XK_Left, Mod1Mask, "\033[1;3D", 0, 0}, + { XK_Left, ShiftMask|Mod1Mask,"\033[1;4D", 0, 0}, + { XK_Left, ControlMask, "\033[1;5D", 0, 0}, + { XK_Left, ShiftMask|ControlMask,"\033[1;6D", 0, 0}, + { XK_Left, ControlMask|Mod1Mask,"\033[1;7D", 0, 0}, + { XK_Left,ShiftMask|ControlMask|Mod1Mask,"\033[1;8D",0, 0}, + { XK_Left, XK_ANY_MOD, "\033[D", 0, -1}, + { XK_Left, XK_ANY_MOD, "\033OD", 0, +1}, + { XK_Right, ShiftMask, "\033[1;2C", 0, 0}, + { XK_Right, Mod1Mask, "\033[1;3C", 0, 0}, + { XK_Right, ShiftMask|Mod1Mask,"\033[1;4C", 0, 0}, + { XK_Right, ControlMask, "\033[1;5C", 0, 0}, + { XK_Right, ShiftMask|ControlMask,"\033[1;6C", 0, 0}, + { XK_Right, ControlMask|Mod1Mask,"\033[1;7C", 0, 0}, + { XK_Right,ShiftMask|ControlMask|Mod1Mask,"\033[1;8C",0, 0}, + { XK_Right, XK_ANY_MOD, "\033[C", 0, -1}, + { XK_Right, XK_ANY_MOD, "\033OC", 0, +1}, + { XK_ISO_Left_Tab, ShiftMask, "\033[Z", 0, 0}, + { XK_Return, Mod1Mask, "\033\r", 0, 0}, + { XK_Return, XK_ANY_MOD, "\r", 0, 0}, + { XK_Insert, ShiftMask, "\033[4l", -1, 0}, + { XK_Insert, ShiftMask, "\033[2;2~", +1, 0}, + { XK_Insert, ControlMask, "\033[L", -1, 0}, + { XK_Insert, ControlMask, "\033[2;5~", +1, 0}, + { XK_Insert, XK_ANY_MOD, "\033[4h", -1, 0}, + { XK_Insert, XK_ANY_MOD, "\033[2~", +1, 0}, + { XK_Delete, ControlMask, "\033[M", -1, 0}, + { XK_Delete, ControlMask, "\033[3;5~", +1, 0}, + { XK_Delete, ShiftMask, "\033[2K", -1, 0}, + { XK_Delete, ShiftMask, "\033[3;2~", +1, 0}, + { XK_Delete, XK_ANY_MOD, "\033[P", -1, 0}, + { XK_Delete, XK_ANY_MOD, "\033[3~", +1, 0}, + { XK_BackSpace, XK_NO_MOD, "\177", 0, 0}, + { XK_BackSpace, Mod1Mask, "\033\177", 0, 0}, + { XK_Home, ShiftMask, "\033[2J", 0, -1}, + { XK_Home, ShiftMask, "\033[1;2H", 0, +1}, + { XK_Home, XK_ANY_MOD, "\033[H", 0, -1}, + { XK_Home, XK_ANY_MOD, "\033[1~", 0, +1}, + { XK_End, ControlMask, "\033[J", -1, 0}, + { XK_End, ControlMask, "\033[1;5F", +1, 0}, + { XK_End, ShiftMask, "\033[K", -1, 0}, + { XK_End, ShiftMask, "\033[1;2F", +1, 0}, + { XK_End, XK_ANY_MOD, "\033[4~", 0, 0}, + { XK_Prior, ControlMask, "\033[5;5~", 0, 0}, + { XK_Prior, ShiftMask, "\033[5;2~", 0, 0}, + { XK_Prior, XK_ANY_MOD, "\033[5~", 0, 0}, + { XK_Next, ControlMask, "\033[6;5~", 0, 0}, + { XK_Next, ShiftMask, "\033[6;2~", 0, 0}, + { XK_Next, XK_ANY_MOD, "\033[6~", 0, 0}, + { XK_F1, XK_NO_MOD, "\033OP" , 0, 0}, + { XK_F1, /* F13 */ ShiftMask, "\033[1;2P", 0, 0}, + { XK_F1, /* F25 */ ControlMask, "\033[1;5P", 0, 0}, + { XK_F1, /* F37 */ Mod4Mask, "\033[1;6P", 0, 0}, + { XK_F1, /* F49 */ Mod1Mask, "\033[1;3P", 0, 0}, + { XK_F1, /* F61 */ Mod3Mask, "\033[1;4P", 0, 0}, + { XK_F2, XK_NO_MOD, "\033OQ" , 0, 0}, + { XK_F2, /* F14 */ ShiftMask, "\033[1;2Q", 0, 0}, + { XK_F2, /* F26 */ ControlMask, "\033[1;5Q", 0, 0}, + { XK_F2, /* F38 */ Mod4Mask, "\033[1;6Q", 0, 0}, + { XK_F2, /* F50 */ Mod1Mask, "\033[1;3Q", 0, 0}, + { XK_F2, /* F62 */ Mod3Mask, "\033[1;4Q", 0, 0}, + { XK_F3, XK_NO_MOD, "\033OR" , 0, 0}, + { XK_F3, /* F15 */ ShiftMask, "\033[1;2R", 0, 0}, + { XK_F3, /* F27 */ ControlMask, "\033[1;5R", 0, 0}, + { XK_F3, /* F39 */ Mod4Mask, "\033[1;6R", 0, 0}, + { XK_F3, /* F51 */ Mod1Mask, "\033[1;3R", 0, 0}, + { XK_F3, /* F63 */ Mod3Mask, "\033[1;4R", 0, 0}, + { XK_F4, XK_NO_MOD, "\033OS" , 0, 0}, + { XK_F4, /* F16 */ ShiftMask, "\033[1;2S", 0, 0}, + { XK_F4, /* F28 */ ControlMask, "\033[1;5S", 0, 0}, + { XK_F4, /* F40 */ Mod4Mask, "\033[1;6S", 0, 0}, + { XK_F4, /* F52 */ Mod1Mask, "\033[1;3S", 0, 0}, + { XK_F5, XK_NO_MOD, "\033[15~", 0, 0}, + { XK_F5, /* F17 */ ShiftMask, "\033[15;2~", 0, 0}, + { XK_F5, /* F29 */ ControlMask, "\033[15;5~", 0, 0}, + { XK_F5, /* F41 */ Mod4Mask, "\033[15;6~", 0, 0}, + { XK_F5, /* F53 */ Mod1Mask, "\033[15;3~", 0, 0}, + { XK_F6, XK_NO_MOD, "\033[17~", 0, 0}, + { XK_F6, /* F18 */ ShiftMask, "\033[17;2~", 0, 0}, + { XK_F6, /* F30 */ ControlMask, "\033[17;5~", 0, 0}, + { XK_F6, /* F42 */ Mod4Mask, "\033[17;6~", 0, 0}, + { XK_F6, /* F54 */ Mod1Mask, "\033[17;3~", 0, 0}, + { XK_F7, XK_NO_MOD, "\033[18~", 0, 0}, + { XK_F7, /* F19 */ ShiftMask, "\033[18;2~", 0, 0}, + { XK_F7, /* F31 */ ControlMask, "\033[18;5~", 0, 0}, + { XK_F7, /* F43 */ Mod4Mask, "\033[18;6~", 0, 0}, + { XK_F7, /* F55 */ Mod1Mask, "\033[18;3~", 0, 0}, + { XK_F8, XK_NO_MOD, "\033[19~", 0, 0}, + { XK_F8, /* F20 */ ShiftMask, "\033[19;2~", 0, 0}, + { XK_F8, /* F32 */ ControlMask, "\033[19;5~", 0, 0}, + { XK_F8, /* F44 */ Mod4Mask, "\033[19;6~", 0, 0}, + { XK_F8, /* F56 */ Mod1Mask, "\033[19;3~", 0, 0}, + { XK_F9, XK_NO_MOD, "\033[20~", 0, 0}, + { XK_F9, /* F21 */ ShiftMask, "\033[20;2~", 0, 0}, + { XK_F9, /* F33 */ ControlMask, "\033[20;5~", 0, 0}, + { XK_F9, /* F45 */ Mod4Mask, "\033[20;6~", 0, 0}, + { XK_F9, /* F57 */ Mod1Mask, "\033[20;3~", 0, 0}, + { XK_F10, XK_NO_MOD, "\033[21~", 0, 0}, + { XK_F10, /* F22 */ ShiftMask, "\033[21;2~", 0, 0}, + { XK_F10, /* F34 */ ControlMask, "\033[21;5~", 0, 0}, + { XK_F10, /* F46 */ Mod4Mask, "\033[21;6~", 0, 0}, + { XK_F10, /* F58 */ Mod1Mask, "\033[21;3~", 0, 0}, + { XK_F11, XK_NO_MOD, "\033[23~", 0, 0}, + { XK_F11, /* F23 */ ShiftMask, "\033[23;2~", 0, 0}, + { XK_F11, /* F35 */ ControlMask, "\033[23;5~", 0, 0}, + { XK_F11, /* F47 */ Mod4Mask, "\033[23;6~", 0, 0}, + { XK_F11, /* F59 */ Mod1Mask, "\033[23;3~", 0, 0}, + { XK_F12, XK_NO_MOD, "\033[24~", 0, 0}, + { XK_F12, /* F24 */ ShiftMask, "\033[24;2~", 0, 0}, + { XK_F12, /* F36 */ ControlMask, "\033[24;5~", 0, 0}, + { XK_F12, /* F48 */ Mod4Mask, "\033[24;6~", 0, 0}, + { XK_F12, /* F60 */ Mod1Mask, "\033[24;3~", 0, 0}, + { XK_F13, XK_NO_MOD, "\033[1;2P", 0, 0}, + { XK_F14, XK_NO_MOD, "\033[1;2Q", 0, 0}, + { XK_F15, XK_NO_MOD, "\033[1;2R", 0, 0}, + { XK_F16, XK_NO_MOD, "\033[1;2S", 0, 0}, + { XK_F17, XK_NO_MOD, "\033[15;2~", 0, 0}, + { XK_F18, XK_NO_MOD, "\033[17;2~", 0, 0}, + { XK_F19, XK_NO_MOD, "\033[18;2~", 0, 0}, + { XK_F20, XK_NO_MOD, "\033[19;2~", 0, 0}, + { XK_F21, XK_NO_MOD, "\033[20;2~", 0, 0}, + { XK_F22, XK_NO_MOD, "\033[21;2~", 0, 0}, + { XK_F23, XK_NO_MOD, "\033[23;2~", 0, 0}, + { XK_F24, XK_NO_MOD, "\033[24;2~", 0, 0}, + { XK_F25, XK_NO_MOD, "\033[1;5P", 0, 0}, + { XK_F26, XK_NO_MOD, "\033[1;5Q", 0, 0}, + { XK_F27, XK_NO_MOD, "\033[1;5R", 0, 0}, + { XK_F28, XK_NO_MOD, "\033[1;5S", 0, 0}, + { XK_F29, XK_NO_MOD, "\033[15;5~", 0, 0}, + { XK_F30, XK_NO_MOD, "\033[17;5~", 0, 0}, + { XK_F31, XK_NO_MOD, "\033[18;5~", 0, 0}, + { XK_F32, XK_NO_MOD, "\033[19;5~", 0, 0}, + { XK_F33, XK_NO_MOD, "\033[20;5~", 0, 0}, + { XK_F34, XK_NO_MOD, "\033[21;5~", 0, 0}, + { XK_F35, XK_NO_MOD, "\033[23;5~", 0, 0}, +}; + +/* + * Selection types' masks. + * Use the same masks as usual. + * Button1Mask is always unset, to make masks match between ButtonPress. + * ButtonRelease and MotionNotify. + * If no match is found, regular selection is used. + */ +static uint selmasks[] = { + [SEL_RECTANGULAR] = Mod1Mask, +}; + +/* + * Printable characters in ASCII, used to estimate the advance width + * of single wide characters. + */ +static char ascii_printable[] = + " !\"#$%&'()*+,-./0123456789:;<=>?" + "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_" + "`abcdefghijklmnopqrstuvwxyz{|}~"; diff --git a/config.mk b/config.mk new file mode 100644 index 0000000..1635264 --- /dev/null +++ b/config.mk @@ -0,0 +1,39 @@ +# st version +VERSION = 0.8.2 + +# Customize below to fit your system + +# paths +PREFIX ?= /usr/local +MANPREFIX = $(PREFIX)/share/man + +X11INC = /usr/X11R6/include +X11LIB = /usr/X11R6/lib + +# include X11 in Ubuntu +# X11INC = /usr/include/X11R6 +# X11LIB = /usr/lib/X11R6 + +PKG_CONFIG = pkg-config + +# includes and libs +INCS = -I$(X11INC) \ + `$(PKG_CONFIG) --cflags fontconfig` \ + `$(PKG_CONFIG) --cflags freetype2` +LIBS = -L$(X11LIB) -lm -lrt -lX11 -lutil -lXft -lXrender \ + `$(PKG_CONFIG) --libs fontconfig` \ + `$(PKG_CONFIG) --libs freetype2` + +# flags +STCPPFLAGS = -DVERSION=\"$(VERSION)\" -D_XOPEN_SOURCE=600 +STCFLAGS = $(INCS) $(STCPPFLAGS) $(CPPFLAGS) $(CFLAGS) +STLDFLAGS = $(LIBS) $(LDFLAGS) + +# OpenBSD: +#CPPFLAGS = -DVERSION=\"$(VERSION)\" -D_XOPEN_SOURCE=600 -D_BSD_SOURCE +#LIBS = -L$(X11LIB) -lm -lX11 -lutil -lXft \ +# `pkg-config --libs fontconfig` \ +# `pkg-config --libs freetype2` + +# compiler and linker +# CC = c99 diff --git a/st-copyout b/st-copyout new file mode 100644 index 0000000..0d19e5a --- /dev/null +++ b/st-copyout @@ -0,0 +1,13 @@ +#!/bin/sh +# Using external pipe with st, give a dmenu prompt of recent commands, +# allowing the user to copy the output of one. +# xclip required for this script. +# By Jaywalker and Luke +tmpfile=$(mktemp /tmp/st-cmd-output.XXXXXX) +trap 'rm "$tmpfile"' 0 1 15 +sed -n "w $tmpfile" +sed -i 's/\x0//g' "$tmpfile" +ps1="$(grep "\S" "$tmpfile" | tail -n 1 | sed 's/^\s*//' | cut -d' ' -f1)" +chosen="$(grep -F "$ps1" "$tmpfile" | sed '$ d' | tac | dmenu -p "Copy which command's output?" -i -l 10 | sed 's/[^^]/[&]/g; s/\^/\\^/g')" +eps1="$(echo "$ps1" | sed 's/[^^]/[&]/g; s/\^/\\^/g')" +awk "/^$chosen$/{p=1;print;next} p&&/$eps1/{p=0};p" "$tmpfile" | xclip -selection clipboard diff --git a/st-urlhandler b/st-urlhandler new file mode 100644 index 0000000..d44bb99 --- /dev/null +++ b/st-urlhandler @@ -0,0 +1,15 @@ +#!/bin/sh + +urlregex="(((http|https)://|www\\.)[a-zA-Z0-9.]*[:]?[a-zA-Z0-9./@$&%?$#=_-]*)|((magnet:\\?xt=urn:btih:)[a-zA-Z0-9]*)" + +# First remove linebreaks and mutt sidebars: +urls="$(sed 's/.*│//g' | tr -d '\n' | + grep -aEo "$urlregex" | # grep only urls as defined above. + uniq | # Ignore neighboring duplicates. + sed 's/^www./http:\/\/www\./g')" + +[ -z "$urls" ] && exit + +chosen="$(echo "$urls" | dmenu -i -p 'Follow which url?' -l 10)" + +setsid xdg-open "$chosen" >/dev/null 2>&1 & diff --git a/st.1 b/st.1 new file mode 100644 index 0000000..57c35f4 --- /dev/null +++ b/st.1 @@ -0,0 +1,194 @@ +.TH ST 1 st\-VERSION +.SH NAME +st \- simple terminal (Luke Smith (https://lukesmith.xyz)'s build) +.SH SYNOPSIS +.B st +.RB [ \-aiv ] +.RB [ \-c +.IR class ] +.RB [ \-f +.IR font ] +.RB [ \-g +.IR geometry ] +.RB [ \-n +.IR name ] +.RB [ \-o +.IR iofile ] +.RB [ \-T +.IR title ] +.RB [ \-t +.IR title ] +.RB [ \-l +.IR line ] +.RB [ \-w +.IR windowid ] +.RB [[ \-e ] +.IR command +.RI [ arguments ...]] +.PP +.B st +.RB [ \-aiv ] +.RB [ \-c +.IR class ] +.RB [ \-f +.IR font ] +.RB [ \-g +.IR geometry ] +.RB [ \-n +.IR name ] +.RB [ \-o +.IR iofile ] +.RB [ \-T +.IR title ] +.RB [ \-t +.IR title ] +.RB [ \-w +.IR windowid ] +.RB \-l +.IR line +.RI [ stty_args ...] +.SH DESCRIPTION +.B st +is a simple terminal emulator. +.SH OPTIONS +.TP +.B \-a +disable alternate screens in terminal +.TP +.BI \-c " class" +defines the window class (default $TERM). +.TP +.BI \-f " font" +defines the +.I font +to use when st is run. +.TP +.BI \-g " geometry" +defines the X11 geometry string. +The form is [=][{xX}][{+-}{+-}]. See +.BR XParseGeometry (3) +for further details. +.TP +.B \-i +will fixate the position given with the -g option. +.TP +.BI \-n " name" +defines the window instance name (default $TERM). +.TP +.BI \-o " iofile" +writes all the I/O to +.I iofile. +This feature is useful when recording st sessions. A value of "-" means +standard output. +.TP +.BI \-T " title" +defines the window title (default 'st'). +.TP +.BI \-t " title" +defines the window title (default 'st'). +.TP +.BI \-w " windowid" +embeds st within the window identified by +.I windowid +.TP +.BI \-l " line" +use a tty +.I line +instead of a pseudo terminal. +.I line +should be a (pseudo-)serial device (e.g. /dev/ttyS0 on Linux for serial port +0). +When this flag is given +remaining arguments are used as flags for +.BR stty(1). +By default st initializes the serial line to 8 bits, no parity, 1 stop bit +and a 38400 baud rate. The speed is set by appending it as last argument +(e.g. 'st -l /dev/ttyS0 115200'). Arguments before the last one are +.BR stty(1) +flags. If you want to set odd parity on 115200 baud use for example 'st -l +/dev/ttyS0 parenb parodd 115200'. Set the number of bits by using for +example 'st -l /dev/ttyS0 cs7 115200'. See +.BR stty(1) +for more arguments and cases. +.TP +.B \-v +prints version information to stderr, then exits. +.TP +.BI \-e " command " [ " arguments " "... ]" +st executes +.I command +instead of the shell. If this is used it +.B must be the last option +on the command line, as in xterm / rxvt. +This option is only intended for compatibility, +and all the remaining arguments are used as a command +even without it. +.SH SHORTCUTS +.TP +.B Alt-j/k or Alt-Up/Down or Alt-Mouse Wheel +Scroll up/down one line at a time. +.TP +.B Alt-u/d or Alt-Page Up/Page Down +Scroll up/down one screen at a time. +.TP +.B Alt-Shift-k/j or Alt-Shift-Page Up/Page Down or Alt-Shift-Mouse Wheel +Increase or decrease font size. +.TP +.B Alt-Home +Reset to default font size. +.TP +.B Shift-Insert or Alt-v +Paste from clipboard. +.TP +.B Alt-c +Copy to clipboard. +.TP +.B Alt-p +Paste/input primary selection. +.TP +.B Alt-l +Show dmenu menu of all URLs on screen and choose one to open. +.TP +.B Alt-y +Show dmenu menu of all URLs on screen and choose one to copy. +.TP +.B Alt-o +Show dmenu menu of all recently run commands and copy the output of the chosen command to the clipboard. +.I xclip +required. +.TP +.B Break +Send a break in the serial line. +Break key is obtained in PC keyboards +pressing at the same time control and pause. +.TP +.B Ctrl-Print Screen +Toggle if st should print to the +.I iofile. +.TP +.B Shift-Print Screen +Print the full screen to the +.I iofile. +.TP +.B Print Screen +Print the selection to the +.I iofile. +.TP +.B Alt-Ctrl +Launch dmenu to enter a unicode codepoint and send the corresponding glyph +to st. +.SH CUSTOMIZATION +.B st +can be customized by creating a custom config.h and (re)compiling the source +code. This keeps it fast, secure and simple. +.SH AUTHORS +See the LICENSE file for the authors. +.SH LICENSE +See the LICENSE file for the terms of redistribution. +.SH SEE ALSO +.BR tabbed (1), +.BR utmp (1), +.BR stty (1) +.SH BUGS +See the TODO file in the distribution. + diff --git a/st.c b/st.c new file mode 100644 index 0000000..0e5e3f5 --- /dev/null +++ b/st.c @@ -0,0 +1,2780 @@ +/* See LICENSE for license details. */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "st.h" +#include "win.h" + +#if defined(__linux) + #include +#elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__) + #include +#elif defined(__FreeBSD__) || defined(__DragonFly__) + #include +#endif + +/* Arbitrary sizes */ +#define UTF_INVALID 0xFFFD +#define UTF_SIZ 4 +#define ESC_BUF_SIZ (128*UTF_SIZ) +#define ESC_ARG_SIZ 16 +#define STR_BUF_SIZ ESC_BUF_SIZ +#define STR_ARG_SIZ ESC_ARG_SIZ +#define HISTSIZE 2000 + +/* macros */ +#define IS_SET(flag) ((term.mode & (flag)) != 0) +#define NUMMAXLEN(x) ((int)(sizeof(x) * 2.56 + 0.5) + 1) +#define ISCONTROLC0(c) (BETWEEN(c, 0, 0x1f) || (c) == '\177') +#define ISCONTROLC1(c) (BETWEEN(c, 0x80, 0x9f)) +#define ISCONTROL(c) (ISCONTROLC0(c) || ISCONTROLC1(c)) +#define ISDELIM(u) (u && wcschr(worddelimiters, u)) +#define TLINE(y) ((y) < term.scr ? term.hist[((y) + term.histi - \ + term.scr + HISTSIZE + 1) % HISTSIZE] : \ + term.line[(y) - term.scr]) + +#define TLINE_HIST(y) ((y) <= HISTSIZE-term.row+2 ? term.hist[(y)] : term.line[(y-HISTSIZE+term.row-3)]) + +/* constants */ +#define ISO14755CMD "dmenu -w \"$WINDOWID\" -p codepoint: ] [;]] []] */ +typedef struct { + char buf[ESC_BUF_SIZ]; /* raw string */ + int len; /* raw string length */ + char priv; + int arg[ESC_ARG_SIZ]; + int narg; /* nb of args */ + char mode[2]; +} CSIEscape; + +/* STR Escape sequence structs */ +/* ESC type [[ [] [;]] ] ESC '\' */ +typedef struct { + char type; /* ESC type ... */ + char buf[STR_BUF_SIZ]; /* raw string */ + int len; /* raw string length */ + char *args[STR_ARG_SIZ]; + int narg; /* nb of args */ +} STREscape; + +static void execsh(char *, char **); +static void stty(char **); +static void sigchld(int); +static void ttywriteraw(const char *, size_t); + +static void csidump(void); +static void csihandle(void); +static void csiparse(void); +static void csireset(void); +static int eschandle(uchar); +static void strdump(void); +static void strhandle(void); +static void strparse(void); +static void strreset(void); + +static void tprinter(char *, size_t); +static void tdumpsel(void); +static void tdumpline(int); +static void tdump(void); +static void tclearregion(int, int, int, int); +static void tcursor(int); +static void tdeletechar(int); +static void tdeleteline(int); +static void tinsertblank(int); +static void tinsertblankline(int); +static int tlinelen(int); +static void tmoveto(int, int); +static void tmoveato(int, int); +static void tnewline(int); +static void tputtab(int); +static void tputc(Rune); +static void treset(void); +static void tscrollup(int, int, int); +static void tscrolldown(int, int, int); +static void tsetattr(int *, int); +static void tsetchar(Rune, Glyph *, int, int); +static void tsetdirt(int, int); +static void tsetscroll(int, int); +static void tswapscreen(void); +static void tsetmode(int, int, int *, int); +static int twrite(const char *, int, int); +static void tfulldirt(void); +static void tcontrolcode(uchar ); +static void tdectest(char ); +static void tdefutf8(char); +static int32_t tdefcolor(int *, int *, int); +static void tdeftran(char); +static void tstrsequence(uchar); + +static void drawregion(int, int, int, int); + +static void selnormalize(void); +static void selscroll(int, int); +static void selsnap(int *, int *, int); + +static size_t utf8decode(const char *, Rune *, size_t); +static Rune utf8decodebyte(char, size_t *); +static char utf8encodebyte(Rune, size_t); +static size_t utf8validate(Rune *, size_t); + +static char *base64dec(const char *); +static char base64dec_getc(const char **); + +static ssize_t xwrite(int, const char *, size_t); + +/* Globals */ +static Term term; +static Selection sel; +static CSIEscape csiescseq; +static STREscape strescseq; +static int iofd = 1; +static int cmdfd; +static pid_t pid; + +static uchar utfbyte[UTF_SIZ + 1] = {0x80, 0, 0xC0, 0xE0, 0xF0}; +static uchar utfmask[UTF_SIZ + 1] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8}; +static Rune utfmin[UTF_SIZ + 1] = { 0, 0, 0x80, 0x800, 0x10000}; +static Rune utfmax[UTF_SIZ + 1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF}; + +ssize_t +xwrite(int fd, const char *s, size_t len) +{ + size_t aux = len; + ssize_t r; + + while (len > 0) { + r = write(fd, s, len); + if (r < 0) + return r; + len -= r; + s += r; + } + + return aux; +} + +void * +xmalloc(size_t len) +{ + void *p; + + if (!(p = malloc(len))) + die("malloc: %s\n", strerror(errno)); + + return p; +} + +void * +xrealloc(void *p, size_t len) +{ + if ((p = realloc(p, len)) == NULL) + die("realloc: %s\n", strerror(errno)); + + return p; +} + +char * +xstrdup(char *s) +{ + if ((s = strdup(s)) == NULL) + die("strdup: %s\n", strerror(errno)); + + return s; +} + +size_t +utf8decode(const char *c, Rune *u, size_t clen) +{ + size_t i, j, len, type; + Rune udecoded; + + *u = UTF_INVALID; + if (!clen) + return 0; + udecoded = utf8decodebyte(c[0], &len); + if (!BETWEEN(len, 1, UTF_SIZ)) + return 1; + for (i = 1, j = 1; i < clen && j < len; ++i, ++j) { + udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type); + if (type != 0) + return j; + } + if (j < len) + return 0; + *u = udecoded; + utf8validate(u, len); + + return len; +} + +Rune +utf8decodebyte(char c, size_t *i) +{ + for (*i = 0; *i < LEN(utfmask); ++(*i)) + if (((uchar)c & utfmask[*i]) == utfbyte[*i]) + return (uchar)c & ~utfmask[*i]; + + return 0; +} + +size_t +utf8encode(Rune u, char *c) +{ + size_t len, i; + + len = utf8validate(&u, 0); + if (len > UTF_SIZ) + return 0; + + for (i = len - 1; i != 0; --i) { + c[i] = utf8encodebyte(u, 0); + u >>= 6; + } + c[0] = utf8encodebyte(u, len); + + return len; +} + +char +utf8encodebyte(Rune u, size_t i) +{ + return utfbyte[i] | (u & ~utfmask[i]); +} + +size_t +utf8validate(Rune *u, size_t i) +{ + if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF)) + *u = UTF_INVALID; + for (i = 1; *u > utfmax[i]; ++i) + ; + + return i; +} + +static const char base64_digits[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, + 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, 0, -1, 0, 0, 0, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +char +base64dec_getc(const char **src) +{ + while (**src && !isprint(**src)) (*src)++; + return *((*src)++); +} + +char * +base64dec(const char *src) +{ + size_t in_len = strlen(src); + char *result, *dst; + + if (in_len % 4) + in_len += 4 - (in_len % 4); + result = dst = xmalloc(in_len / 4 * 3 + 1); + while (*src) { + int a = base64_digits[(unsigned char) base64dec_getc(&src)]; + int b = base64_digits[(unsigned char) base64dec_getc(&src)]; + int c = base64_digits[(unsigned char) base64dec_getc(&src)]; + int d = base64_digits[(unsigned char) base64dec_getc(&src)]; + + *dst++ = (a << 2) | ((b & 0x30) >> 4); + if (c == -1) + break; + *dst++ = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2); + if (d == -1) + break; + *dst++ = ((c & 0x03) << 6) | d; + } + *dst = '\0'; + return result; +} + +void +selinit(void) +{ + sel.mode = SEL_IDLE; + sel.snap = 0; + sel.ob.x = -1; +} + +int +tlinelen(int y) +{ + int i = term.col; + + if (TLINE(y)[i - 1].mode & ATTR_WRAP) + return i; + + while (i > 0 && TLINE(y)[i - 1].u == ' ') + --i; + + return i; +} + +int +tlinehistlen(int y) +{ + int i = term.col; + + if (TLINE_HIST(y)[i - 1].mode & ATTR_WRAP) + return i; + + while (i > 0 && TLINE_HIST(y)[i - 1].u == ' ') + --i; + + return i; +} + +void +selstart(int col, int row, int snap) +{ + selclear(); + sel.mode = SEL_EMPTY; + sel.type = SEL_REGULAR; + sel.alt = IS_SET(MODE_ALTSCREEN); + sel.snap = snap; + sel.oe.x = sel.ob.x = col; + sel.oe.y = sel.ob.y = row; + selnormalize(); + + if (sel.snap != 0) + sel.mode = SEL_READY; + tsetdirt(sel.nb.y, sel.ne.y); +} + +void +selextend(int col, int row, int type, int done) +{ + int oldey, oldex, oldsby, oldsey, oldtype; + + if (sel.mode == SEL_IDLE) + return; + if (done && sel.mode == SEL_EMPTY) { + selclear(); + return; + } + + oldey = sel.oe.y; + oldex = sel.oe.x; + oldsby = sel.nb.y; + oldsey = sel.ne.y; + oldtype = sel.type; + + sel.oe.x = col; + sel.oe.y = row; + selnormalize(); + sel.type = type; + + if (oldey != sel.oe.y || oldex != sel.oe.x || oldtype != sel.type || sel.mode == SEL_EMPTY) + tsetdirt(MIN(sel.nb.y, oldsby), MAX(sel.ne.y, oldsey)); + + sel.mode = done ? SEL_IDLE : SEL_READY; +} + +void +selnormalize(void) +{ + int i; + + if (sel.type == SEL_REGULAR && sel.ob.y != sel.oe.y) { + sel.nb.x = sel.ob.y < sel.oe.y ? sel.ob.x : sel.oe.x; + sel.ne.x = sel.ob.y < sel.oe.y ? sel.oe.x : sel.ob.x; + } else { + sel.nb.x = MIN(sel.ob.x, sel.oe.x); + sel.ne.x = MAX(sel.ob.x, sel.oe.x); + } + sel.nb.y = MIN(sel.ob.y, sel.oe.y); + sel.ne.y = MAX(sel.ob.y, sel.oe.y); + + selsnap(&sel.nb.x, &sel.nb.y, -1); + selsnap(&sel.ne.x, &sel.ne.y, +1); + + /* expand selection over line breaks */ + if (sel.type == SEL_RECTANGULAR) + return; + i = tlinelen(sel.nb.y); + if (i < sel.nb.x) + sel.nb.x = i; + if (tlinelen(sel.ne.y) <= sel.ne.x) + sel.ne.x = term.col - 1; +} + +int +selected(int x, int y) +{ + if (sel.mode == SEL_EMPTY || sel.ob.x == -1 || + sel.alt != IS_SET(MODE_ALTSCREEN)) + return 0; + + if (sel.type == SEL_RECTANGULAR) + return BETWEEN(y, sel.nb.y, sel.ne.y) + && BETWEEN(x, sel.nb.x, sel.ne.x); + + return BETWEEN(y, sel.nb.y, sel.ne.y) + && (y != sel.nb.y || x >= sel.nb.x) + && (y != sel.ne.y || x <= sel.ne.x); +} + +void +selsnap(int *x, int *y, int direction) +{ + int newx, newy, xt, yt; + int delim, prevdelim; + Glyph *gp, *prevgp; + + switch (sel.snap) { + case SNAP_WORD: + /* + * Snap around if the word wraps around at the end or + * beginning of a line. + */ + prevgp = &TLINE(*y)[*x]; + prevdelim = ISDELIM(prevgp->u); + for (;;) { + newx = *x + direction; + newy = *y; + if (!BETWEEN(newx, 0, term.col - 1)) { + newy += direction; + newx = (newx + term.col) % term.col; + if (!BETWEEN(newy, 0, term.row - 1)) + break; + + if (direction > 0) + yt = *y, xt = *x; + else + yt = newy, xt = newx; + if (!(TLINE(yt)[xt].mode & ATTR_WRAP)) + break; + } + + if (newx >= tlinelen(newy)) + break; + + gp = &TLINE(newy)[newx]; + delim = ISDELIM(gp->u); + if (!(gp->mode & ATTR_WDUMMY) && (delim != prevdelim + || (delim && gp->u != prevgp->u))) + break; + + *x = newx; + *y = newy; + prevgp = gp; + prevdelim = delim; + } + break; + case SNAP_LINE: + /* + * Snap around if the the previous line or the current one + * has set ATTR_WRAP at its end. Then the whole next or + * previous line will be selected. + */ + *x = (direction < 0) ? 0 : term.col - 1; + if (direction < 0) { + for (; *y > 0; *y += direction) { + if (!(TLINE(*y-1)[term.col-1].mode + & ATTR_WRAP)) { + break; + } + } + } else if (direction > 0) { + for (; *y < term.row-1; *y += direction) { + if (!(TLINE(*y)[term.col-1].mode + & ATTR_WRAP)) { + break; + } + } + } + break; + } +} + +char * +getsel(void) +{ + char *str, *ptr; + int y, bufsize, lastx, linelen; + Glyph *gp, *last; + + if (sel.ob.x == -1) + return NULL; + + bufsize = (term.col+1) * (sel.ne.y-sel.nb.y+1) * UTF_SIZ; + ptr = str = xmalloc(bufsize); + + /* append every set & selected glyph to the selection */ + for (y = sel.nb.y; y <= sel.ne.y; y++) { + if ((linelen = tlinelen(y)) == 0) { + *ptr++ = '\n'; + continue; + } + + if (sel.type == SEL_RECTANGULAR) { + gp = &TLINE(y)[sel.nb.x]; + lastx = sel.ne.x; + } else { + gp = &TLINE(y)[sel.nb.y == y ? sel.nb.x : 0]; + lastx = (sel.ne.y == y) ? sel.ne.x : term.col-1; + } + last = &TLINE(y)[MIN(lastx, linelen-1)]; + while (last >= gp && last->u == ' ') + --last; + + for ( ; gp <= last; ++gp) { + if (gp->mode & ATTR_WDUMMY) + continue; + + ptr += utf8encode(gp->u, ptr); + } + + /* + * Copy and pasting of line endings is inconsistent + * in the inconsistent terminal and GUI world. + * The best solution seems like to produce '\n' when + * something is copied from st and convert '\n' to + * '\r', when something to be pasted is received by + * st. + * FIXME: Fix the computer world. + */ + if ((y < sel.ne.y || lastx >= linelen) && !(last->mode & ATTR_WRAP)) + *ptr++ = '\n'; + } + *ptr = 0; + return str; +} + +void +selclear(void) +{ + if (sel.ob.x == -1) + return; + sel.mode = SEL_IDLE; + sel.ob.x = -1; + tsetdirt(sel.nb.y, sel.ne.y); +} + +void +die(const char *errstr, ...) +{ + va_list ap; + + va_start(ap, errstr); + vfprintf(stderr, errstr, ap); + va_end(ap); + exit(1); +} + +void +execsh(char *cmd, char **args) +{ + char *sh, *prog; + const struct passwd *pw; + + errno = 0; + if ((pw = getpwuid(getuid())) == NULL) { + if (errno) + die("getpwuid: %s\n", strerror(errno)); + else + die("who are you?\n"); + } + + if ((sh = getenv("SHELL")) == NULL) + sh = (pw->pw_shell[0]) ? pw->pw_shell : cmd; + + if (args) + prog = args[0]; + else if (utmp) + prog = utmp; + else + prog = sh; + DEFAULT(args, ((char *[]) {prog, NULL})); + + unsetenv("COLUMNS"); + unsetenv("LINES"); + unsetenv("TERMCAP"); + setenv("LOGNAME", pw->pw_name, 1); + setenv("USER", pw->pw_name, 1); + setenv("SHELL", sh, 1); + setenv("HOME", pw->pw_dir, 1); + setenv("TERM", termname, 1); + + signal(SIGCHLD, SIG_DFL); + signal(SIGHUP, SIG_DFL); + signal(SIGINT, SIG_DFL); + signal(SIGQUIT, SIG_DFL); + signal(SIGTERM, SIG_DFL); + signal(SIGALRM, SIG_DFL); + + execvp(prog, args); + _exit(1); +} + +void +sigchld(int a) +{ + int stat; + pid_t p; + + if ((p = waitpid(pid, &stat, WNOHANG)) < 0) + die("waiting for pid %hd failed: %s\n", pid, strerror(errno)); + + if (pid != p) + return; + + if (WIFEXITED(stat) && WEXITSTATUS(stat)) + die("child exited with status %d\n", WEXITSTATUS(stat)); + else if (WIFSIGNALED(stat)) + die("child terminated due to signal %d\n", WTERMSIG(stat)); + exit(0); +} + +void +stty(char **args) +{ + char cmd[_POSIX_ARG_MAX], **p, *q, *s; + size_t n, siz; + + if ((n = strlen(stty_args)) > sizeof(cmd)-1) + die("incorrect stty parameters\n"); + memcpy(cmd, stty_args, n); + q = cmd + n; + siz = sizeof(cmd) - n; + for (p = args; p && (s = *p); ++p) { + if ((n = strlen(s)) > siz-1) + die("stty parameter length too long\n"); + *q++ = ' '; + memcpy(q, s, n); + q += n; + siz -= n + 1; + } + *q = '\0'; + if (system(cmd) != 0) + perror("Couldn't call stty"); +} + +int +ttynew(char *line, char *cmd, char *out, char **args) +{ + int m, s; + + if (out) { + term.mode |= MODE_PRINT; + iofd = (!strcmp(out, "-")) ? + 1 : open(out, O_WRONLY | O_CREAT, 0666); + if (iofd < 0) { + fprintf(stderr, "Error opening %s:%s\n", + out, strerror(errno)); + } + } + + if (line) { + if ((cmdfd = open(line, O_RDWR)) < 0) + die("open line '%s' failed: %s\n", + line, strerror(errno)); + dup2(cmdfd, 0); + stty(args); + return cmdfd; + } + + /* seems to work fine on linux, openbsd and freebsd */ + if (openpty(&m, &s, NULL, NULL, NULL) < 0) + die("openpty failed: %s\n", strerror(errno)); + + switch (pid = fork()) { + case -1: + die("fork failed: %s\n", strerror(errno)); + break; + case 0: + close(iofd); + setsid(); /* create a new process group */ + dup2(s, 0); + dup2(s, 1); + dup2(s, 2); + if (ioctl(s, TIOCSCTTY, NULL) < 0) + die("ioctl TIOCSCTTY failed: %s\n", strerror(errno)); + close(s); + close(m); +#ifdef __OpenBSD__ + if (pledge("stdio getpw proc exec", NULL) == -1) + die("pledge\n"); +#endif + execsh(cmd, args); + break; + default: +#ifdef __OpenBSD__ + if (pledge("stdio rpath tty proc", NULL) == -1) + die("pledge\n"); +#endif + close(s); + cmdfd = m; + signal(SIGCHLD, sigchld); + break; + } + return cmdfd; +} + +size_t +ttyread(void) +{ + static char buf[BUFSIZ]; + static int buflen = 0; + int written; + int ret; + + /* append read bytes to unprocessed bytes */ + if ((ret = read(cmdfd, buf+buflen, LEN(buf)-buflen)) < 0) + die("couldn't read from shell: %s\n", strerror(errno)); + buflen += ret; + + written = twrite(buf, buflen, 0); + buflen -= written; + /* keep any uncomplete utf8 char for the next call */ + if (buflen > 0) + memmove(buf, buf + written, buflen); + + return ret; +} + +void +ttywrite(const char *s, size_t n, int may_echo) +{ + const char *next; + Arg arg = (Arg) { .i = term.scr }; + + kscrolldown(&arg); + + if (may_echo && IS_SET(MODE_ECHO)) + twrite(s, n, 1); + + if (!IS_SET(MODE_CRLF)) { + ttywriteraw(s, n); + return; + } + + /* This is similar to how the kernel handles ONLCR for ttys */ + while (n > 0) { + if (*s == '\r') { + next = s + 1; + ttywriteraw("\r\n", 2); + } else { + next = memchr(s, '\r', n); + DEFAULT(next, s + n); + ttywriteraw(s, next - s); + } + n -= next - s; + s = next; + } +} + +void +ttywriteraw(const char *s, size_t n) +{ + fd_set wfd, rfd; + ssize_t r; + size_t lim = 256; + + /* + * Remember that we are using a pty, which might be a modem line. + * Writing too much will clog the line. That's why we are doing this + * dance. + * FIXME: Migrate the world to Plan 9. + */ + while (n > 0) { + FD_ZERO(&wfd); + FD_ZERO(&rfd); + FD_SET(cmdfd, &wfd); + FD_SET(cmdfd, &rfd); + + /* Check if we can write. */ + if (pselect(cmdfd+1, &rfd, &wfd, NULL, NULL, NULL) < 0) { + if (errno == EINTR) + continue; + die("select failed: %s\n", strerror(errno)); + } + if (FD_ISSET(cmdfd, &wfd)) { + /* + * Only write the bytes written by ttywrite() or the + * default of 256. This seems to be a reasonable value + * for a serial line. Bigger values might clog the I/O. + */ + if ((r = write(cmdfd, s, (n < lim)? n : lim)) < 0) + goto write_error; + if (r < n) { + /* + * We weren't able to write out everything. + * This means the buffer is getting full + * again. Empty it. + */ + if (n < lim) + lim = ttyread(); + n -= r; + s += r; + } else { + /* All bytes have been written. */ + break; + } + } + if (FD_ISSET(cmdfd, &rfd)) + lim = ttyread(); + } + return; + +write_error: + die("write error on tty: %s\n", strerror(errno)); +} + +void +ttyresize(int tw, int th) +{ + struct winsize w; + + w.ws_row = term.row; + w.ws_col = term.col; + w.ws_xpixel = tw; + w.ws_ypixel = th; + if (ioctl(cmdfd, TIOCSWINSZ, &w) < 0) + fprintf(stderr, "Couldn't set window size: %s\n", strerror(errno)); +} + +void +ttyhangup() +{ + /* Send SIGHUP to shell */ + kill(pid, SIGHUP); +} + +int +tattrset(int attr) +{ + int i, j; + + for (i = 0; i < term.row-1; i++) { + for (j = 0; j < term.col-1; j++) { + if (term.line[i][j].mode & attr) + return 1; + } + } + + return 0; +} + +void +tsetdirt(int top, int bot) +{ + int i; + + LIMIT(top, 0, term.row-1); + LIMIT(bot, 0, term.row-1); + + for (i = top; i <= bot; i++) + term.dirty[i] = 1; +} + +void +tsetdirtattr(int attr) +{ + int i, j; + + for (i = 0; i < term.row-1; i++) { + for (j = 0; j < term.col-1; j++) { + if (term.line[i][j].mode & attr) { + tsetdirt(i, i); + break; + } + } + } +} + +void +tfulldirt(void) +{ + tsetdirt(0, term.row-1); +} + +void +tcursor(int mode) +{ + static TCursor c[2]; + int alt = IS_SET(MODE_ALTSCREEN); + + if (mode == CURSOR_SAVE) { + c[alt] = term.c; + } else if (mode == CURSOR_LOAD) { + term.c = c[alt]; + tmoveto(c[alt].x, c[alt].y); + } +} + +void +treset(void) +{ + uint i; + + term.c = (TCursor){{ + .mode = ATTR_NULL, + .fg = defaultfg, + .bg = defaultbg + }, .x = 0, .y = 0, .state = CURSOR_DEFAULT}; + + memset(term.tabs, 0, term.col * sizeof(*term.tabs)); + for (i = tabspaces; i < term.col; i += tabspaces) + term.tabs[i] = 1; + term.top = 0; + term.bot = term.row - 1; + term.mode = MODE_WRAP|MODE_UTF8; + memset(term.trantbl, CS_USA, sizeof(term.trantbl)); + term.charset = 0; + + for (i = 0; i < 2; i++) { + tmoveto(0, 0); + tcursor(CURSOR_SAVE); + tclearregion(0, 0, term.col-1, term.row-1); + tswapscreen(); + } +} + +void +tnew(int col, int row) +{ + term = (Term){ .c = { .attr = { .fg = defaultfg, .bg = defaultbg } } }; + clock_gettime(CLOCK_MONOTONIC, &term.last_ximspot_update); + tresize(col, row); + treset(); +} + +void +tswapscreen(void) +{ + Line *tmp = term.line; + + term.line = term.alt; + term.alt = tmp; + term.mode ^= MODE_ALTSCREEN; + tfulldirt(); +} + +void +kscrolldown(const Arg* a) +{ + int n = a->i; + + if (n < 0) + n = term.row + n; + + if (n > term.scr) + n = term.scr; + + if (term.scr > 0) { + term.scr -= n; + selscroll(0, -n); + tfulldirt(); + } +} + +void +kscrollup(const Arg* a) +{ + int n = a->i; + + if (n < 0) + n = term.row + n; + + if (term.scr <= HISTSIZE-n) { + term.scr += n; + selscroll(0, n); + tfulldirt(); + } +} + +void +tscrolldown(int orig, int n, int copyhist) +{ + int i; + Line temp; + + LIMIT(n, 0, term.bot-orig+1); + + if (copyhist) { + term.histi = (term.histi - 1 + HISTSIZE) % HISTSIZE; + temp = term.hist[term.histi]; + term.hist[term.histi] = term.line[term.bot]; + term.line[term.bot] = temp; + } + + tsetdirt(orig, term.bot-n); + tclearregion(0, term.bot-n+1, term.col-1, term.bot); + + for (i = term.bot; i >= orig+n; i--) { + temp = term.line[i]; + term.line[i] = term.line[i-n]; + term.line[i-n] = temp; + } + + selscroll(orig, n); +} + +void +tscrollup(int orig, int n, int copyhist) +{ + int i; + Line temp; + + LIMIT(n, 0, term.bot-orig+1); + + if (copyhist) { + term.histi = (term.histi + 1) % HISTSIZE; + temp = term.hist[term.histi]; + term.hist[term.histi] = term.line[orig]; + term.line[orig] = temp; + } + + if (term.scr > 0 && term.scr < HISTSIZE) + term.scr = MIN(term.scr + n, HISTSIZE-1); + + tclearregion(0, orig, term.col-1, orig+n-1); + tsetdirt(orig+n, term.bot); + + for (i = orig; i <= term.bot-n; i++) { + temp = term.line[i]; + term.line[i] = term.line[i+n]; + term.line[i+n] = temp; + } + + selscroll(orig, -n); +} + +void +selscroll(int orig, int n) +{ + if (sel.ob.x == -1) + return; + + if (BETWEEN(sel.ob.y, orig, term.bot) || BETWEEN(sel.oe.y, orig, term.bot)) { + if ((sel.ob.y += n) > term.bot || (sel.oe.y += n) < term.top) { + selclear(); + return; + } + if (sel.type == SEL_RECTANGULAR) { + if (sel.ob.y < term.top) + sel.ob.y = term.top; + if (sel.oe.y > term.bot) + sel.oe.y = term.bot; + } else { + if (sel.ob.y < term.top) { + sel.ob.y = term.top; + sel.ob.x = 0; + } + if (sel.oe.y > term.bot) { + sel.oe.y = term.bot; + sel.oe.x = term.col; + } + } + selnormalize(); + } +} + +void +tnewline(int first_col) +{ + int y = term.c.y; + + if (y == term.bot) { + tscrollup(term.top, 1, 1); + } else { + y++; + } + tmoveto(first_col ? 0 : term.c.x, y); +} + +void +csiparse(void) +{ + char *p = csiescseq.buf, *np; + long int v; + + csiescseq.narg = 0; + if (*p == '?') { + csiescseq.priv = 1; + p++; + } + + csiescseq.buf[csiescseq.len] = '\0'; + while (p < csiescseq.buf+csiescseq.len) { + np = NULL; + v = strtol(p, &np, 10); + if (np == p) + v = 0; + if (v == LONG_MAX || v == LONG_MIN) + v = -1; + csiescseq.arg[csiescseq.narg++] = v; + p = np; + if (*p != ';' || csiescseq.narg == ESC_ARG_SIZ) + break; + p++; + } + csiescseq.mode[0] = *p++; + csiescseq.mode[1] = (p < csiescseq.buf+csiescseq.len) ? *p : '\0'; +} + +/* for absolute user moves, when decom is set */ +void +tmoveato(int x, int y) +{ + tmoveto(x, y + ((term.c.state & CURSOR_ORIGIN) ? term.top: 0)); +} + +void +tmoveto(int x, int y) +{ + int miny, maxy; + + if (term.c.state & CURSOR_ORIGIN) { + miny = term.top; + maxy = term.bot; + } else { + miny = 0; + maxy = term.row - 1; + } + term.c.state &= ~CURSOR_WRAPNEXT; + term.c.x = LIMIT(x, 0, term.col-1); + term.c.y = LIMIT(y, miny, maxy); +} + +void +tsetchar(Rune u, Glyph *attr, int x, int y) +{ + static char *vt100_0[62] = { /* 0x41 - 0x7e */ + "↑", "↓", "→", "←", "█", "▚", "☃", /* A - G */ + 0, 0, 0, 0, 0, 0, 0, 0, /* H - O */ + 0, 0, 0, 0, 0, 0, 0, 0, /* P - W */ + 0, 0, 0, 0, 0, 0, 0, " ", /* X - _ */ + "◆", "▒", "␉", "␌", "␍", "␊", "°", "±", /* ` - g */ + "␤", "␋", "┘", "┐", "┌", "└", "┼", "⎺", /* h - o */ + "⎻", "─", "⎼", "⎽", "├", "┤", "┴", "┬", /* p - w */ + "│", "≤", "≥", "π", "≠", "£", "·", /* x - ~ */ + }; + + /* + * The table is proudly stolen from rxvt. + */ + if (term.trantbl[term.charset] == CS_GRAPHIC0 && + BETWEEN(u, 0x41, 0x7e) && vt100_0[u - 0x41]) + utf8decode(vt100_0[u - 0x41], &u, UTF_SIZ); + + if (term.line[y][x].mode & ATTR_WIDE) { + if (x+1 < term.col) { + term.line[y][x+1].u = ' '; + term.line[y][x+1].mode &= ~ATTR_WDUMMY; + } + } else if (term.line[y][x].mode & ATTR_WDUMMY) { + term.line[y][x-1].u = ' '; + term.line[y][x-1].mode &= ~ATTR_WIDE; + } + + term.dirty[y] = 1; + term.line[y][x] = *attr; + term.line[y][x].u = u; + + if (isboxdraw(u)) + term.line[y][x].mode |= ATTR_BOXDRAW; +} + +void +tclearregion(int x1, int y1, int x2, int y2) +{ + int x, y, temp; + Glyph *gp; + + if (x1 > x2) + temp = x1, x1 = x2, x2 = temp; + if (y1 > y2) + temp = y1, y1 = y2, y2 = temp; + + LIMIT(x1, 0, term.col-1); + LIMIT(x2, 0, term.col-1); + LIMIT(y1, 0, term.row-1); + LIMIT(y2, 0, term.row-1); + + for (y = y1; y <= y2; y++) { + term.dirty[y] = 1; + for (x = x1; x <= x2; x++) { + gp = &term.line[y][x]; + if (selected(x, y)) + selclear(); + gp->fg = term.c.attr.fg; + gp->bg = term.c.attr.bg; + gp->mode = 0; + gp->u = ' '; + } + } +} + +void +tdeletechar(int n) +{ + int dst, src, size; + Glyph *line; + + LIMIT(n, 0, term.col - term.c.x); + + dst = term.c.x; + src = term.c.x + n; + size = term.col - src; + line = term.line[term.c.y]; + + memmove(&line[dst], &line[src], size * sizeof(Glyph)); + tclearregion(term.col-n, term.c.y, term.col-1, term.c.y); +} + +void +tinsertblank(int n) +{ + int dst, src, size; + Glyph *line; + + LIMIT(n, 0, term.col - term.c.x); + + dst = term.c.x + n; + src = term.c.x; + size = term.col - dst; + line = term.line[term.c.y]; + + memmove(&line[dst], &line[src], size * sizeof(Glyph)); + tclearregion(src, term.c.y, dst - 1, term.c.y); +} + +void +tinsertblankline(int n) +{ + if (BETWEEN(term.c.y, term.top, term.bot)) + tscrolldown(term.c.y, n, 0); +} + +void +tdeleteline(int n) +{ + if (BETWEEN(term.c.y, term.top, term.bot)) + tscrollup(term.c.y, n, 0); +} + +int32_t +tdefcolor(int *attr, int *npar, int l) +{ + int32_t idx = -1; + uint r, g, b; + + switch (attr[*npar + 1]) { + case 2: /* direct color in RGB space */ + if (*npar + 4 >= l) { + fprintf(stderr, + "erresc(38): Incorrect number of parameters (%d)\n", + *npar); + break; + } + r = attr[*npar + 2]; + g = attr[*npar + 3]; + b = attr[*npar + 4]; + *npar += 4; + if (!BETWEEN(r, 0, 255) || !BETWEEN(g, 0, 255) || !BETWEEN(b, 0, 255)) + fprintf(stderr, "erresc: bad rgb color (%u,%u,%u)\n", + r, g, b); + else + idx = TRUECOLOR(r, g, b); + break; + case 5: /* indexed color */ + if (*npar + 2 >= l) { + fprintf(stderr, + "erresc(38): Incorrect number of parameters (%d)\n", + *npar); + break; + } + *npar += 2; + if (!BETWEEN(attr[*npar], 0, 255)) + fprintf(stderr, "erresc: bad fgcolor %d\n", attr[*npar]); + else + idx = attr[*npar]; + break; + case 0: /* implemented defined (only foreground) */ + case 1: /* transparent */ + case 3: /* direct color in CMY space */ + case 4: /* direct color in CMYK space */ + default: + fprintf(stderr, + "erresc(38): gfx attr %d unknown\n", attr[*npar]); + break; + } + + return idx; +} + +void +tsetattr(int *attr, int l) +{ + int i; + int32_t idx; + + for (i = 0; i < l; i++) { + switch (attr[i]) { + case 0: + term.c.attr.mode &= ~( + ATTR_BOLD | + ATTR_FAINT | + ATTR_ITALIC | + ATTR_UNDERLINE | + ATTR_BLINK | + ATTR_REVERSE | + ATTR_INVISIBLE | + ATTR_STRUCK ); + term.c.attr.fg = defaultfg; + term.c.attr.bg = defaultbg; + break; + case 1: + term.c.attr.mode |= ATTR_BOLD; + break; + case 2: + term.c.attr.mode |= ATTR_FAINT; + break; + case 3: + term.c.attr.mode |= ATTR_ITALIC; + break; + case 4: + term.c.attr.mode |= ATTR_UNDERLINE; + break; + case 5: /* slow blink */ + /* FALLTHROUGH */ + case 6: /* rapid blink */ + term.c.attr.mode |= ATTR_BLINK; + break; + case 7: + term.c.attr.mode |= ATTR_REVERSE; + break; + case 8: + term.c.attr.mode |= ATTR_INVISIBLE; + break; + case 9: + term.c.attr.mode |= ATTR_STRUCK; + break; + case 22: + term.c.attr.mode &= ~(ATTR_BOLD | ATTR_FAINT); + break; + case 23: + term.c.attr.mode &= ~ATTR_ITALIC; + break; + case 24: + term.c.attr.mode &= ~ATTR_UNDERLINE; + break; + case 25: + term.c.attr.mode &= ~ATTR_BLINK; + break; + case 27: + term.c.attr.mode &= ~ATTR_REVERSE; + break; + case 28: + term.c.attr.mode &= ~ATTR_INVISIBLE; + break; + case 29: + term.c.attr.mode &= ~ATTR_STRUCK; + break; + case 38: + if ((idx = tdefcolor(attr, &i, l)) >= 0) + term.c.attr.fg = idx; + break; + case 39: + term.c.attr.fg = defaultfg; + break; + case 48: + if ((idx = tdefcolor(attr, &i, l)) >= 0) + term.c.attr.bg = idx; + break; + case 49: + term.c.attr.bg = defaultbg; + break; + default: + if (BETWEEN(attr[i], 30, 37)) { + term.c.attr.fg = attr[i] - 30; + } else if (BETWEEN(attr[i], 40, 47)) { + term.c.attr.bg = attr[i] - 40; + } else if (BETWEEN(attr[i], 90, 97)) { + term.c.attr.fg = attr[i] - 90 + 8; + } else if (BETWEEN(attr[i], 100, 107)) { + term.c.attr.bg = attr[i] - 100 + 8; + } else { + fprintf(stderr, + "erresc(default): gfx attr %d unknown\n", + attr[i]); + csidump(); + } + break; + } + } +} + +void +tsetscroll(int t, int b) +{ + int temp; + + LIMIT(t, 0, term.row-1); + LIMIT(b, 0, term.row-1); + if (t > b) { + temp = t; + t = b; + b = temp; + } + term.top = t; + term.bot = b; +} + +void +tsetmode(int priv, int set, int *args, int narg) +{ + int alt, *lim; + + for (lim = args + narg; args < lim; ++args) { + if (priv) { + switch (*args) { + case 1: /* DECCKM -- Cursor key */ + xsetmode(set, MODE_APPCURSOR); + break; + case 5: /* DECSCNM -- Reverse video */ + xsetmode(set, MODE_REVERSE); + break; + case 6: /* DECOM -- Origin */ + MODBIT(term.c.state, set, CURSOR_ORIGIN); + tmoveato(0, 0); + break; + case 7: /* DECAWM -- Auto wrap */ + MODBIT(term.mode, set, MODE_WRAP); + break; + case 0: /* Error (IGNORED) */ + case 2: /* DECANM -- ANSI/VT52 (IGNORED) */ + case 3: /* DECCOLM -- Column (IGNORED) */ + case 4: /* DECSCLM -- Scroll (IGNORED) */ + case 8: /* DECARM -- Auto repeat (IGNORED) */ + case 18: /* DECPFF -- Printer feed (IGNORED) */ + case 19: /* DECPEX -- Printer extent (IGNORED) */ + case 42: /* DECNRCM -- National characters (IGNORED) */ + case 12: /* att610 -- Start blinking cursor (IGNORED) */ + break; + case 25: /* DECTCEM -- Text Cursor Enable Mode */ + xsetmode(!set, MODE_HIDE); + break; + case 9: /* X10 mouse compatibility mode */ + xsetpointermotion(0); + xsetmode(0, MODE_MOUSE); + xsetmode(set, MODE_MOUSEX10); + break; + case 1000: /* 1000: report button press */ + xsetpointermotion(0); + xsetmode(0, MODE_MOUSE); + xsetmode(set, MODE_MOUSEBTN); + break; + case 1002: /* 1002: report motion on button press */ + xsetpointermotion(0); + xsetmode(0, MODE_MOUSE); + xsetmode(set, MODE_MOUSEMOTION); + break; + case 1003: /* 1003: enable all mouse motions */ + xsetpointermotion(set); + xsetmode(0, MODE_MOUSE); + xsetmode(set, MODE_MOUSEMANY); + break; + case 1004: /* 1004: send focus events to tty */ + xsetmode(set, MODE_FOCUS); + break; + case 1006: /* 1006: extended reporting mode */ + xsetmode(set, MODE_MOUSESGR); + break; + case 1034: + xsetmode(set, MODE_8BIT); + break; + case 1049: /* swap screen & set/restore cursor as xterm */ + if (!allowaltscreen) + break; + tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD); + /* FALLTHROUGH */ + case 47: /* swap screen */ + case 1047: + if (!allowaltscreen) + break; + alt = IS_SET(MODE_ALTSCREEN); + if (alt) { + tclearregion(0, 0, term.col-1, + term.row-1); + } + if (set ^ alt) /* set is always 1 or 0 */ + tswapscreen(); + if (*args != 1049) + break; + /* FALLTHROUGH */ + case 1048: + tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD); + break; + case 2004: /* 2004: bracketed paste mode */ + xsetmode(set, MODE_BRCKTPASTE); + break; + /* Not implemented mouse modes. See comments there. */ + case 1001: /* mouse highlight mode; can hang the + terminal by design when implemented. */ + case 1005: /* UTF-8 mouse mode; will confuse + applications not supporting UTF-8 + and luit. */ + case 1015: /* urxvt mangled mouse mode; incompatible + and can be mistaken for other control + codes. */ + break; + default: + fprintf(stderr, + "erresc: unknown private set/reset mode %d\n", + *args); + break; + } + } else { + switch (*args) { + case 0: /* Error (IGNORED) */ + break; + case 2: + xsetmode(set, MODE_KBDLOCK); + break; + case 4: /* IRM -- Insertion-replacement */ + MODBIT(term.mode, set, MODE_INSERT); + break; + case 12: /* SRM -- Send/Receive */ + MODBIT(term.mode, !set, MODE_ECHO); + break; + case 20: /* LNM -- Linefeed/new line */ + MODBIT(term.mode, set, MODE_CRLF); + break; + default: + fprintf(stderr, + "erresc: unknown set/reset mode %d\n", + *args); + break; + } + } + } +} + +void +csihandle(void) +{ + char buf[40]; + int len; + + switch (csiescseq.mode[0]) { + default: + unknown: + fprintf(stderr, "erresc: unknown csi "); + csidump(); + /* die(""); */ + break; + case '@': /* ICH -- Insert blank char */ + DEFAULT(csiescseq.arg[0], 1); + tinsertblank(csiescseq.arg[0]); + break; + case 'A': /* CUU -- Cursor Up */ + DEFAULT(csiescseq.arg[0], 1); + tmoveto(term.c.x, term.c.y-csiescseq.arg[0]); + break; + case 'B': /* CUD -- Cursor Down */ + case 'e': /* VPR --Cursor Down */ + DEFAULT(csiescseq.arg[0], 1); + tmoveto(term.c.x, term.c.y+csiescseq.arg[0]); + break; + case 'i': /* MC -- Media Copy */ + switch (csiescseq.arg[0]) { + case 0: + tdump(); + break; + case 1: + tdumpline(term.c.y); + break; + case 2: + tdumpsel(); + break; + case 4: + term.mode &= ~MODE_PRINT; + break; + case 5: + term.mode |= MODE_PRINT; + break; + } + break; + case 'c': /* DA -- Device Attributes */ + if (csiescseq.arg[0] == 0) + ttywrite(vtiden, strlen(vtiden), 0); + break; + case 'C': /* CUF -- Cursor Forward */ + case 'a': /* HPR -- Cursor Forward */ + DEFAULT(csiescseq.arg[0], 1); + tmoveto(term.c.x+csiescseq.arg[0], term.c.y); + break; + case 'D': /* CUB -- Cursor Backward */ + DEFAULT(csiescseq.arg[0], 1); + tmoveto(term.c.x-csiescseq.arg[0], term.c.y); + break; + case 'E': /* CNL -- Cursor Down and first col */ + DEFAULT(csiescseq.arg[0], 1); + tmoveto(0, term.c.y+csiescseq.arg[0]); + break; + case 'F': /* CPL -- Cursor Up and first col */ + DEFAULT(csiescseq.arg[0], 1); + tmoveto(0, term.c.y-csiescseq.arg[0]); + break; + case 'g': /* TBC -- Tabulation clear */ + switch (csiescseq.arg[0]) { + case 0: /* clear current tab stop */ + term.tabs[term.c.x] = 0; + break; + case 3: /* clear all the tabs */ + memset(term.tabs, 0, term.col * sizeof(*term.tabs)); + break; + default: + goto unknown; + } + break; + case 'G': /* CHA -- Move to */ + case '`': /* HPA */ + DEFAULT(csiescseq.arg[0], 1); + tmoveto(csiescseq.arg[0]-1, term.c.y); + break; + case 'H': /* CUP -- Move to */ + case 'f': /* HVP */ + DEFAULT(csiescseq.arg[0], 1); + DEFAULT(csiescseq.arg[1], 1); + tmoveato(csiescseq.arg[1]-1, csiescseq.arg[0]-1); + break; + case 'I': /* CHT -- Cursor Forward Tabulation tab stops */ + DEFAULT(csiescseq.arg[0], 1); + tputtab(csiescseq.arg[0]); + break; + case 'J': /* ED -- Clear screen */ + switch (csiescseq.arg[0]) { + case 0: /* below */ + tclearregion(term.c.x, term.c.y, term.col-1, term.c.y); + if (term.c.y < term.row-1) { + tclearregion(0, term.c.y+1, term.col-1, + term.row-1); + } + break; + case 1: /* above */ + if (term.c.y > 1) + tclearregion(0, 0, term.col-1, term.c.y-1); + tclearregion(0, term.c.y, term.c.x, term.c.y); + break; + case 2: /* all */ + tclearregion(0, 0, term.col-1, term.row-1); + break; + default: + goto unknown; + } + break; + case 'K': /* EL -- Clear line */ + switch (csiescseq.arg[0]) { + case 0: /* right */ + tclearregion(term.c.x, term.c.y, term.col-1, + term.c.y); + break; + case 1: /* left */ + tclearregion(0, term.c.y, term.c.x, term.c.y); + break; + case 2: /* all */ + tclearregion(0, term.c.y, term.col-1, term.c.y); + break; + } + break; + case 'S': /* SU -- Scroll line up */ + DEFAULT(csiescseq.arg[0], 1); + tscrollup(term.top, csiescseq.arg[0], 0); + break; + case 'T': /* SD -- Scroll line down */ + DEFAULT(csiescseq.arg[0], 1); + tscrolldown(term.top, csiescseq.arg[0], 0); + break; + case 'L': /* IL -- Insert blank lines */ + DEFAULT(csiescseq.arg[0], 1); + tinsertblankline(csiescseq.arg[0]); + break; + case 'l': /* RM -- Reset Mode */ + tsetmode(csiescseq.priv, 0, csiescseq.arg, csiescseq.narg); + break; + case 'M': /* DL -- Delete lines */ + DEFAULT(csiescseq.arg[0], 1); + tdeleteline(csiescseq.arg[0]); + break; + case 'X': /* ECH -- Erase char */ + DEFAULT(csiescseq.arg[0], 1); + tclearregion(term.c.x, term.c.y, + term.c.x + csiescseq.arg[0] - 1, term.c.y); + break; + case 'P': /* DCH -- Delete char */ + DEFAULT(csiescseq.arg[0], 1); + tdeletechar(csiescseq.arg[0]); + break; + case 'Z': /* CBT -- Cursor Backward Tabulation tab stops */ + DEFAULT(csiescseq.arg[0], 1); + tputtab(-csiescseq.arg[0]); + break; + case 'd': /* VPA -- Move to */ + DEFAULT(csiescseq.arg[0], 1); + tmoveato(term.c.x, csiescseq.arg[0]-1); + break; + case 'h': /* SM -- Set terminal mode */ + tsetmode(csiescseq.priv, 1, csiescseq.arg, csiescseq.narg); + break; + case 'm': /* SGR -- Terminal attribute (color) */ + tsetattr(csiescseq.arg, csiescseq.narg); + break; + case 'n': /* DSR – Device Status Report (cursor position) */ + if (csiescseq.arg[0] == 6) { + len = snprintf(buf, sizeof(buf),"\033[%i;%iR", + term.c.y+1, term.c.x+1); + ttywrite(buf, len, 0); + } + break; + case 'r': /* DECSTBM -- Set Scrolling Region */ + if (csiescseq.priv) { + goto unknown; + } else { + DEFAULT(csiescseq.arg[0], 1); + DEFAULT(csiescseq.arg[1], term.row); + tsetscroll(csiescseq.arg[0]-1, csiescseq.arg[1]-1); + tmoveato(0, 0); + } + break; + case 's': /* DECSC -- Save cursor position (ANSI.SYS) */ + tcursor(CURSOR_SAVE); + break; + case 'u': /* DECRC -- Restore cursor position (ANSI.SYS) */ + tcursor(CURSOR_LOAD); + break; + case ' ': + switch (csiescseq.mode[1]) { + case 'q': /* DECSCUSR -- Set Cursor Style */ + if (xsetcursor(csiescseq.arg[0])) + goto unknown; + break; + default: + goto unknown; + } + break; + } +} + +void +csidump(void) +{ + int i; + uint c; + + fprintf(stderr, "ESC["); + for (i = 0; i < csiescseq.len; i++) { + c = csiescseq.buf[i] & 0xff; + if (isprint(c)) { + putc(c, stderr); + } else if (c == '\n') { + fprintf(stderr, "(\\n)"); + } else if (c == '\r') { + fprintf(stderr, "(\\r)"); + } else if (c == 0x1b) { + fprintf(stderr, "(\\e)"); + } else { + fprintf(stderr, "(%02x)", c); + } + } + putc('\n', stderr); +} + +void +csireset(void) +{ + memset(&csiescseq, 0, sizeof(csiescseq)); +} + +void +strhandle(void) +{ + char *p = NULL, *dec; + int j, narg, par; + + term.esc &= ~(ESC_STR_END|ESC_STR); + strparse(); + par = (narg = strescseq.narg) ? atoi(strescseq.args[0]) : 0; + + switch (strescseq.type) { + case ']': /* OSC -- Operating System Command */ + switch (par) { + case 0: + case 1: + case 2: + if (narg > 1) + xsettitle(strescseq.args[1]); + return; + case 52: + if (narg > 2) { + dec = base64dec(strescseq.args[2]); + if (dec) { + xsetsel(dec); + xclipcopy(); + } else { + fprintf(stderr, "erresc: invalid base64\n"); + } + } + return; + case 4: /* color set */ + case 10: /* foreground set */ + case 11: /* background set */ + case 12: /* cursor color */ + if ((par == 4 && narg < 3) || narg < 2) + break; + p = strescseq.args[((par == 4) ? 2 : 1)]; + /* FALLTHROUGH */ + case 104: /* color reset, here p = NULL */ + if (par == 10) + j = defaultfg; + else if (par == 11) + j = defaultbg; + else if (par == 12) + j = defaultcs; + else + j = (narg > 1) ? atoi(strescseq.args[1]) : -1; + + if (xsetcolorname(j, p)) { + if (par == 104 && narg <= 1) + return; /* color reset without parameter */ + fprintf(stderr, "erresc: invalid color j=%d, p=%s\n", + j, p ? p : "(null)"); + } else { + /* + * TODO if defaultbg color is changed, borders + * are dirty + */ + if (j == defaultbg) + xclearwin(); + redraw(); + } + return; + } + break; + case 'k': /* old title set compatibility */ + xsettitle(strescseq.args[0]); + return; + case 'P': /* DCS -- Device Control String */ + term.mode |= ESC_DCS; + case '_': /* APC -- Application Program Command */ + case '^': /* PM -- Privacy Message */ + return; + } + + fprintf(stderr, "erresc: unknown str "); + strdump(); +} + +void +strparse(void) +{ + int c; + char *p = strescseq.buf; + + strescseq.narg = 0; + strescseq.buf[strescseq.len] = '\0'; + + if (*p == '\0') + return; + + while (strescseq.narg < STR_ARG_SIZ) { + strescseq.args[strescseq.narg++] = p; + while ((c = *p) != ';' && c != '\0') + ++p; + if (c == '\0') + return; + *p++ = '\0'; + } +} + +void +strdump(void) +{ + int i; + uint c; + + fprintf(stderr, "ESC%c", strescseq.type); + for (i = 0; i < strescseq.len; i++) { + c = strescseq.buf[i] & 0xff; + if (c == '\0') { + putc('\n', stderr); + return; + } else if (isprint(c)) { + putc(c, stderr); + } else if (c == '\n') { + fprintf(stderr, "(\\n)"); + } else if (c == '\r') { + fprintf(stderr, "(\\r)"); + } else if (c == 0x1b) { + fprintf(stderr, "(\\e)"); + } else { + fprintf(stderr, "(%02x)", c); + } + } + fprintf(stderr, "ESC\\\n"); +} + +void +strreset(void) +{ + memset(&strescseq, 0, sizeof(strescseq)); +} + +void +sendbreak(const Arg *arg) +{ + if (tcsendbreak(cmdfd, 0)) + perror("Error sending break"); +} + +void +tprinter(char *s, size_t len) +{ + if (iofd != -1 && xwrite(iofd, s, len) < 0) { + perror("Error writing to output file"); + close(iofd); + iofd = -1; + } +} + +void +externalpipe(const Arg *arg) +{ + int to[2]; + char buf[UTF_SIZ]; + void (*oldsigpipe)(int); + Glyph *bp, *end; + int lastpos, n, newline; + + if (pipe(to) == -1) + return; + + switch (fork()) { + case -1: + close(to[0]); + close(to[1]); + return; + case 0: + dup2(to[0], STDIN_FILENO); + close(to[0]); + close(to[1]); + execvp(((char **)arg->v)[0], (char **)arg->v); + fprintf(stderr, "st: execvp %s\n", ((char **)arg->v)[0]); + perror("failed"); + exit(0); + } + + close(to[0]); + /* ignore sigpipe for now, in case child exists early */ + oldsigpipe = signal(SIGPIPE, SIG_IGN); + newline = 0; + /* modify externalpipe patch to pipe history too */ + for (n = 0; n <= HISTSIZE + 2; n++) { + bp = TLINE_HIST(n); + lastpos = MIN(tlinehistlen(n) +1, term.col) - 1; + if (lastpos < 0) + break; + if (lastpos == 0) + continue; + end = &bp[lastpos + 1]; + for (; bp < end; ++bp) + if (xwrite(to[1], buf, utf8encode(bp->u, buf)) < 0) + break; + if ((newline = TLINE_HIST(n)[lastpos].mode & ATTR_WRAP)) + continue; + if (xwrite(to[1], "\n", 1) < 0) + break; + newline = 0; + } + if (newline) + (void)xwrite(to[1], "\n", 1); + close(to[1]); + /* restore */ + signal(SIGPIPE, oldsigpipe); +} + +void +iso14755(const Arg *arg) +{ + FILE *p; + char *us, *e, codepoint[9], uc[UTF_SIZ]; + unsigned long utf32; + + if (!(p = popen(ISO14755CMD, "r"))) + return; + + us = fgets(codepoint, sizeof(codepoint), p); + pclose(p); + + if (!us || *us == '\0' || *us == '-' || strlen(us) > 7) + return; + if ((utf32 = strtoul(us, &e, 16)) == ULONG_MAX || + (*e != '\n' && *e != '\0')) + return; + + ttywrite(uc, utf8encode(utf32, uc), 1); +} + +void +toggleprinter(const Arg *arg) +{ + term.mode ^= MODE_PRINT; +} + +void +printscreen(const Arg *arg) +{ + tdump(); +} + +void +printsel(const Arg *arg) +{ + tdumpsel(); +} + +void +tdumpsel(void) +{ + char *ptr; + + if ((ptr = getsel())) { + tprinter(ptr, strlen(ptr)); + free(ptr); + } +} + +void +tdumpline(int n) +{ + char buf[UTF_SIZ]; + Glyph *bp, *end; + + bp = &term.line[n][0]; + end = &bp[MIN(tlinelen(n), term.col) - 1]; + if (bp != end || bp->u != ' ') { + for ( ;bp <= end; ++bp) + tprinter(buf, utf8encode(bp->u, buf)); + } + tprinter("\n", 1); +} + +void +tdump(void) +{ + int i; + + for (i = 0; i < term.row; ++i) + tdumpline(i); +} + +void +tputtab(int n) +{ + uint x = term.c.x; + + if (n > 0) { + while (x < term.col && n--) + for (++x; x < term.col && !term.tabs[x]; ++x) + /* nothing */ ; + } else if (n < 0) { + while (x > 0 && n++) + for (--x; x > 0 && !term.tabs[x]; --x) + /* nothing */ ; + } + term.c.x = LIMIT(x, 0, term.col-1); +} + +void +tdefutf8(char ascii) +{ + if (ascii == 'G') + term.mode |= MODE_UTF8; + else if (ascii == '@') + term.mode &= ~MODE_UTF8; +} + +void +tdeftran(char ascii) +{ + static char cs[] = "0B"; + static int vcs[] = {CS_GRAPHIC0, CS_USA}; + char *p; + + if ((p = strchr(cs, ascii)) == NULL) { + fprintf(stderr, "esc unhandled charset: ESC ( %c\n", ascii); + } else { + term.trantbl[term.icharset] = vcs[p - cs]; + } +} + +void +tdectest(char c) +{ + int x, y; + + if (c == '8') { /* DEC screen alignment test. */ + for (x = 0; x < term.col; ++x) { + for (y = 0; y < term.row; ++y) + tsetchar('E', &term.c.attr, x, y); + } + } +} + +void +tstrsequence(uchar c) +{ + strreset(); + + switch (c) { + case 0x90: /* DCS -- Device Control String */ + c = 'P'; + term.esc |= ESC_DCS; + break; + case 0x9f: /* APC -- Application Program Command */ + c = '_'; + break; + case 0x9e: /* PM -- Privacy Message */ + c = '^'; + break; + case 0x9d: /* OSC -- Operating System Command */ + c = ']'; + break; + } + strescseq.type = c; + term.esc |= ESC_STR; +} + +void +tcontrolcode(uchar ascii) +{ + switch (ascii) { + case '\t': /* HT */ + tputtab(1); + return; + case '\b': /* BS */ + tmoveto(term.c.x-1, term.c.y); + return; + case '\r': /* CR */ + tmoveto(0, term.c.y); + return; + case '\f': /* LF */ + case '\v': /* VT */ + case '\n': /* LF */ + /* go to first col if the mode is set */ + tnewline(IS_SET(MODE_CRLF)); + return; + case '\a': /* BEL */ + if (term.esc & ESC_STR_END) { + /* backwards compatibility to xterm */ + strhandle(); + } else { + xbell(); + } + break; + case '\033': /* ESC */ + csireset(); + term.esc &= ~(ESC_CSI|ESC_ALTCHARSET|ESC_TEST); + term.esc |= ESC_START; + return; + case '\016': /* SO (LS1 -- Locking shift 1) */ + case '\017': /* SI (LS0 -- Locking shift 0) */ + term.charset = 1 - (ascii - '\016'); + return; + case '\032': /* SUB */ + tsetchar('?', &term.c.attr, term.c.x, term.c.y); + case '\030': /* CAN */ + csireset(); + break; + case '\005': /* ENQ (IGNORED) */ + case '\000': /* NUL (IGNORED) */ + case '\021': /* XON (IGNORED) */ + case '\023': /* XOFF (IGNORED) */ + case 0177: /* DEL (IGNORED) */ + return; + case 0x80: /* TODO: PAD */ + case 0x81: /* TODO: HOP */ + case 0x82: /* TODO: BPH */ + case 0x83: /* TODO: NBH */ + case 0x84: /* TODO: IND */ + break; + case 0x85: /* NEL -- Next line */ + tnewline(1); /* always go to first col */ + break; + case 0x86: /* TODO: SSA */ + case 0x87: /* TODO: ESA */ + break; + case 0x88: /* HTS -- Horizontal tab stop */ + term.tabs[term.c.x] = 1; + break; + case 0x89: /* TODO: HTJ */ + case 0x8a: /* TODO: VTS */ + case 0x8b: /* TODO: PLD */ + case 0x8c: /* TODO: PLU */ + case 0x8d: /* TODO: RI */ + case 0x8e: /* TODO: SS2 */ + case 0x8f: /* TODO: SS3 */ + case 0x91: /* TODO: PU1 */ + case 0x92: /* TODO: PU2 */ + case 0x93: /* TODO: STS */ + case 0x94: /* TODO: CCH */ + case 0x95: /* TODO: MW */ + case 0x96: /* TODO: SPA */ + case 0x97: /* TODO: EPA */ + case 0x98: /* TODO: SOS */ + case 0x99: /* TODO: SGCI */ + break; + case 0x9a: /* DECID -- Identify Terminal */ + ttywrite(vtiden, strlen(vtiden), 0); + break; + case 0x9b: /* TODO: CSI */ + case 0x9c: /* TODO: ST */ + break; + case 0x90: /* DCS -- Device Control String */ + case 0x9d: /* OSC -- Operating System Command */ + case 0x9e: /* PM -- Privacy Message */ + case 0x9f: /* APC -- Application Program Command */ + tstrsequence(ascii); + return; + } + /* only CAN, SUB, \a and C1 chars interrupt a sequence */ + term.esc &= ~(ESC_STR_END|ESC_STR); +} + +/* + * returns 1 when the sequence is finished and it hasn't to read + * more characters for this sequence, otherwise 0 + */ +int +eschandle(uchar ascii) +{ + switch (ascii) { + case '[': + term.esc |= ESC_CSI; + return 0; + case '#': + term.esc |= ESC_TEST; + return 0; + case '%': + term.esc |= ESC_UTF8; + return 0; + case 'P': /* DCS -- Device Control String */ + case '_': /* APC -- Application Program Command */ + case '^': /* PM -- Privacy Message */ + case ']': /* OSC -- Operating System Command */ + case 'k': /* old title set compatibility */ + tstrsequence(ascii); + return 0; + case 'n': /* LS2 -- Locking shift 2 */ + case 'o': /* LS3 -- Locking shift 3 */ + term.charset = 2 + (ascii - 'n'); + break; + case '(': /* GZD4 -- set primary charset G0 */ + case ')': /* G1D4 -- set secondary charset G1 */ + case '*': /* G2D4 -- set tertiary charset G2 */ + case '+': /* G3D4 -- set quaternary charset G3 */ + term.icharset = ascii - '('; + term.esc |= ESC_ALTCHARSET; + return 0; + case 'D': /* IND -- Linefeed */ + if (term.c.y == term.bot) { + tscrollup(term.top, 1, 1); + } else { + tmoveto(term.c.x, term.c.y+1); + } + break; + case 'E': /* NEL -- Next line */ + tnewline(1); /* always go to first col */ + break; + case 'H': /* HTS -- Horizontal tab stop */ + term.tabs[term.c.x] = 1; + break; + case 'M': /* RI -- Reverse index */ + if (term.c.y == term.top) { + tscrolldown(term.top, 1, 1); + } else { + tmoveto(term.c.x, term.c.y-1); + } + break; + case 'Z': /* DECID -- Identify Terminal */ + ttywrite(vtiden, strlen(vtiden), 0); + break; + case 'c': /* RIS -- Reset to initial state */ + treset(); + resettitle(); + xloadcols(); + break; + case '=': /* DECPAM -- Application keypad */ + xsetmode(1, MODE_APPKEYPAD); + break; + case '>': /* DECPNM -- Normal keypad */ + xsetmode(0, MODE_APPKEYPAD); + break; + case '7': /* DECSC -- Save Cursor */ + tcursor(CURSOR_SAVE); + break; + case '8': /* DECRC -- Restore Cursor */ + tcursor(CURSOR_LOAD); + break; + case '\\': /* ST -- String Terminator */ + if (term.esc & ESC_STR_END) + strhandle(); + break; + default: + fprintf(stderr, "erresc: unknown sequence ESC 0x%02X '%c'\n", + (uchar) ascii, isprint(ascii)? ascii:'.'); + break; + } + return 1; +} + +void +tputc(Rune u) +{ + char c[UTF_SIZ]; + int control; + int width, len; + Glyph *gp; + + control = ISCONTROL(u); + if (!IS_SET(MODE_UTF8) && !IS_SET(MODE_SIXEL)) { + c[0] = u; + width = len = 1; + } else { + len = utf8encode(u, c); + if (!control && (width = wcwidth(u)) == -1) { + memcpy(c, "\357\277\275", 4); /* UTF_INVALID */ + width = 1; + } + } + + if (IS_SET(MODE_PRINT)) + tprinter(c, len); + + /* + * STR sequence must be checked before anything else + * because it uses all following characters until it + * receives a ESC, a SUB, a ST or any other C1 control + * character. + */ + if (term.esc & ESC_STR) { + if (u == '\a' || u == 030 || u == 032 || u == 033 || + ISCONTROLC1(u)) { + term.esc &= ~(ESC_START|ESC_STR|ESC_DCS); + if (IS_SET(MODE_SIXEL)) { + /* TODO: render sixel */; + term.mode &= ~MODE_SIXEL; + return; + } + term.esc |= ESC_STR_END; + goto check_control_code; + } + + if (IS_SET(MODE_SIXEL)) { + /* TODO: implement sixel mode */ + return; + } + if (term.esc&ESC_DCS && strescseq.len == 0 && u == 'q') + term.mode |= MODE_SIXEL; + + if (strescseq.len+len >= sizeof(strescseq.buf)-1) { + /* + * Here is a bug in terminals. If the user never sends + * some code to stop the str or esc command, then st + * will stop responding. But this is better than + * silently failing with unknown characters. At least + * then users will report back. + * + * In the case users ever get fixed, here is the code: + */ + /* + * term.esc = 0; + * strhandle(); + */ + return; + } + + memmove(&strescseq.buf[strescseq.len], c, len); + strescseq.len += len; + return; + } + +check_control_code: + /* + * Actions of control codes must be performed as soon they arrive + * because they can be embedded inside a control sequence, and + * they must not cause conflicts with sequences. + */ + if (control) { + tcontrolcode(u); + /* + * control codes are not shown ever + */ + return; + } else if (term.esc & ESC_START) { + if (term.esc & ESC_CSI) { + csiescseq.buf[csiescseq.len++] = u; + if (BETWEEN(u, 0x40, 0x7E) + || csiescseq.len >= \ + sizeof(csiescseq.buf)-1) { + term.esc = 0; + csiparse(); + csihandle(); + } + return; + } else if (term.esc & ESC_UTF8) { + tdefutf8(u); + } else if (term.esc & ESC_ALTCHARSET) { + tdeftran(u); + } else if (term.esc & ESC_TEST) { + tdectest(u); + } else { + if (!eschandle(u)) + return; + /* sequence already finished */ + } + term.esc = 0; + /* + * All characters which form part of a sequence are not + * printed + */ + return; + } + if (sel.ob.x != -1 && BETWEEN(term.c.y, sel.ob.y, sel.oe.y)) + selclear(); + + gp = &term.line[term.c.y][term.c.x]; + if (IS_SET(MODE_WRAP) && (term.c.state & CURSOR_WRAPNEXT)) { + gp->mode |= ATTR_WRAP; + tnewline(1); + gp = &term.line[term.c.y][term.c.x]; + } + + if (IS_SET(MODE_INSERT) && term.c.x+width < term.col) + memmove(gp+width, gp, (term.col - term.c.x - width) * sizeof(Glyph)); + + if (term.c.x+width > term.col) { + tnewline(1); + gp = &term.line[term.c.y][term.c.x]; + } + + tsetchar(u, &term.c.attr, term.c.x, term.c.y); + + if (width == 2) { + gp->mode |= ATTR_WIDE; + if (term.c.x+1 < term.col) { + gp[1].u = '\0'; + gp[1].mode = ATTR_WDUMMY; + } + } + if (term.c.x+width < term.col) { + tmoveto(term.c.x+width, term.c.y); + } else { + term.c.state |= CURSOR_WRAPNEXT; + } +} + +int +twrite(const char *buf, int buflen, int show_ctrl) +{ + int charsize; + Rune u; + int n; + + for (n = 0; n < buflen; n += charsize) { + if (IS_SET(MODE_UTF8) && !IS_SET(MODE_SIXEL)) { + /* process a complete utf8 char */ + charsize = utf8decode(buf + n, &u, buflen - n); + if (charsize == 0) + break; + } else { + u = buf[n] & 0xFF; + charsize = 1; + } + if (show_ctrl && ISCONTROL(u)) { + if (u & 0x80) { + u &= 0x7f; + tputc('^'); + tputc('['); + } else if (u != '\n' && u != '\r' && u != '\t') { + u ^= 0x40; + tputc('^'); + } + } + tputc(u); + } + return n; +} + +void +tresize(int col, int row) +{ + int i, j; + int minrow = MIN(row, term.row); + int mincol = MIN(col, term.col); + int *bp; + TCursor c; + + if (col < 1 || row < 1) { + fprintf(stderr, + "tresize: error resizing to %dx%d\n", col, row); + return; + } + + /* + * slide screen to keep cursor where we expect it - + * tscrollup would work here, but we can optimize to + * memmove because we're freeing the earlier lines + */ + for (i = 0; i <= term.c.y - row; i++) { + free(term.line[i]); + free(term.alt[i]); + } + /* ensure that both src and dst are not NULL */ + if (i > 0) { + memmove(term.line, term.line + i, row * sizeof(Line)); + memmove(term.alt, term.alt + i, row * sizeof(Line)); + } + for (i += row; i < term.row; i++) { + free(term.line[i]); + free(term.alt[i]); + } + + /* resize to new height */ + term.line = xrealloc(term.line, row * sizeof(Line)); + term.alt = xrealloc(term.alt, row * sizeof(Line)); + term.dirty = xrealloc(term.dirty, row * sizeof(*term.dirty)); + term.tabs = xrealloc(term.tabs, col * sizeof(*term.tabs)); + + for (i = 0; i < HISTSIZE; i++) { + term.hist[i] = xrealloc(term.hist[i], col * sizeof(Glyph)); + for (j = mincol; j < col; j++) { + term.hist[i][j] = term.c.attr; + term.hist[i][j].u = ' '; + } + } + + /* resize each row to new width, zero-pad if needed */ + for (i = 0; i < minrow; i++) { + term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph)); + term.alt[i] = xrealloc(term.alt[i], col * sizeof(Glyph)); + } + + /* allocate any new rows */ + for (/* i = minrow */; i < row; i++) { + term.line[i] = xmalloc(col * sizeof(Glyph)); + term.alt[i] = xmalloc(col * sizeof(Glyph)); + } + if (col > term.col) { + bp = term.tabs + term.col; + + memset(bp, 0, sizeof(*term.tabs) * (col - term.col)); + while (--bp > term.tabs && !*bp) + /* nothing */ ; + for (bp += tabspaces; bp < term.tabs + col; bp += tabspaces) + *bp = 1; + } + /* update terminal size */ + term.col = col; + term.row = row; + /* reset scrolling region */ + tsetscroll(0, row-1); + /* make use of the LIMIT in tmoveto */ + tmoveto(term.c.x, term.c.y); + /* Clearing both screens (it makes dirty all lines) */ + c = term.c; + for (i = 0; i < 2; i++) { + if (mincol < col && 0 < minrow) { + tclearregion(mincol, 0, col - 1, minrow - 1); + } + if (0 < col && minrow < row) { + tclearregion(0, minrow, col - 1, row - 1); + } + tswapscreen(); + tcursor(CURSOR_LOAD); + } + term.c = c; +} + +void +resettitle(void) +{ + xsettitle(NULL); +} + +void +drawregion(int x1, int y1, int x2, int y2) +{ + int y; + for (y = y1; y < y2; y++) { + if (!term.dirty[y]) + continue; + + term.dirty[y] = 0; + xdrawline(TLINE(y), x1, y, x2); + } +} + +void +draw(void) +{ + int cx = term.c.x; + + if (!xstartdraw()) + return; + + /* adjust cursor position */ + LIMIT(term.ocx, 0, term.col-1); + LIMIT(term.ocy, 0, term.row-1); + if (term.line[term.ocy][term.ocx].mode & ATTR_WDUMMY) + term.ocx--; + if (term.line[term.c.y][cx].mode & ATTR_WDUMMY) + cx--; + + drawregion(0, 0, term.col, term.row); + if (term.scr == 0) + xdrawcursor(cx, term.c.y, term.line[term.c.y][cx], + term.ocx, term.ocy, term.line[term.ocy][term.ocx]); + term.ocx = cx, term.ocy = term.c.y; + xfinishdraw(); + + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + if (ximspot_update_interval && TIMEDIFF(now, term.last_ximspot_update) > ximspot_update_interval) { + xximspot(term.ocx, term.ocy); + term.last_ximspot_update = now; + } +} + +void +redraw(void) +{ + tfulldirt(); + draw(); +} diff --git a/st.h b/st.h new file mode 100644 index 0000000..33cc5d4 --- /dev/null +++ b/st.h @@ -0,0 +1,147 @@ +/* See LICENSE for license details. */ + +#include +#include + +/* macros */ +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#define MAX(a, b) ((a) < (b) ? (b) : (a)) +#define LEN(a) (sizeof(a) / sizeof(a)[0]) +#define BETWEEN(x, a, b) ((a) <= (x) && (x) <= (b)) +#define DIVCEIL(n, d) (((n) + ((d) - 1)) / (d)) +#define DEFAULT(a, b) (a) = (a) ? (a) : (b) +#define LIMIT(x, a, b) (x) = (x) < (a) ? (a) : (x) > (b) ? (b) : (x) +#define ATTRCMP(a, b) ((a).mode != (b).mode || (a).fg != (b).fg || \ + (a).bg != (b).bg) +#define TIMEDIFF(t1, t2) ((t1.tv_sec-t2.tv_sec)*1000 + \ + (t1.tv_nsec-t2.tv_nsec)/1E6) +#define MODBIT(x, set, bit) ((set) ? ((x) |= (bit)) : ((x) &= ~(bit))) + +#define TRUECOLOR(r,g,b) (1 << 24 | (r) << 16 | (g) << 8 | (b)) +#define IS_TRUECOL(x) (1 << 24 & (x)) + +enum glyph_attribute { + ATTR_NULL = 0, + ATTR_BOLD = 1 << 0, + ATTR_FAINT = 1 << 1, + ATTR_ITALIC = 1 << 2, + ATTR_UNDERLINE = 1 << 3, + ATTR_BLINK = 1 << 4, + ATTR_REVERSE = 1 << 5, + ATTR_INVISIBLE = 1 << 6, + ATTR_STRUCK = 1 << 7, + ATTR_WRAP = 1 << 8, + ATTR_WIDE = 1 << 9, + ATTR_WDUMMY = 1 << 10, + ATTR_BOXDRAW = 1 << 11, + ATTR_BOLD_FAINT = ATTR_BOLD | ATTR_FAINT, +}; + +enum selection_mode { + SEL_IDLE = 0, + SEL_EMPTY = 1, + SEL_READY = 2 +}; + +enum selection_type { + SEL_REGULAR = 1, + SEL_RECTANGULAR = 2 +}; + +enum selection_snap { + SNAP_WORD = 1, + SNAP_LINE = 2 +}; + +typedef unsigned char uchar; +typedef unsigned int uint; +typedef unsigned long ulong; +typedef unsigned short ushort; + +typedef uint_least32_t Rune; + +#define Glyph Glyph_ +typedef struct { + Rune u; /* character code */ + ushort mode; /* attribute flags */ + uint32_t fg; /* foreground */ + uint32_t bg; /* background */ +} Glyph; + +typedef Glyph *Line; + +typedef union { + int i; + uint ui; + float f; + const void *v; +} Arg; + +typedef struct { + uint b; + uint mask; + void (*func)(const Arg *); + const Arg arg; +} MouseKey; + +void die(const char *, ...); +void redraw(void); +void draw(void); + +void externalpipe(const Arg *); +void iso14755(const Arg *); +void kscrolldown(const Arg *); +void kscrollup(const Arg *); +void printscreen(const Arg *); +void printsel(const Arg *); +void sendbreak(const Arg *); +void toggleprinter(const Arg *); + +int tattrset(int); +void tnew(int, int); +void tresize(int, int); +void tsetdirtattr(int); +void ttyhangup(void); +int ttynew(char *, char *, char *, char **); +size_t ttyread(void); +void ttyresize(int, int); +void ttywrite(const char *, size_t, int); + +void resettitle(void); + +void selclear(void); +void selinit(void); +void selstart(int, int, int); +void selextend(int, int, int, int); +int selected(int, int); +char *getsel(void); + +size_t utf8encode(Rune, char *); + +void *xmalloc(size_t); +void *xrealloc(void *, size_t); +char *xstrdup(char *); + +int isboxdraw(Rune); +ushort boxdrawindex(const Glyph *); +#ifdef XFT_VERSION +/* only exposed to x.c, otherwise we'll need Xft.h for the types */ +void boxdraw_xinit(Display *, Colormap, XftDraw *, Visual *); +void drawboxes(int, int, int, int, XftColor *, XftColor *, const XftGlyphFontSpec *, int); +#endif + +/* config.h globals */ +extern char *utmp; +extern char *stty_args; +extern char *vtiden; +extern wchar_t *worddelimiters; +extern int allowaltscreen; +extern char *termname; +extern unsigned int tabspaces; +extern unsigned int defaultfg; +extern unsigned int defaultbg; +extern unsigned int defaultcs; +extern const int boxdraw, boxdraw_bold, boxdraw_braille; +extern float alpha; +extern MouseKey mkeys[]; +extern int ximspot_update_interval; diff --git a/st.info b/st.info new file mode 100644 index 0000000..78ffd30 --- /dev/null +++ b/st.info @@ -0,0 +1,222 @@ +st| simpleterm, + acsc=+C\,D-A.B0E``aaffgghFiGjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~, + am, + bce, + bel=^G, + blink=\E[5m, + bold=\E[1m, + cbt=\E[Z, + cvvis=\E[?25h, + civis=\E[?25l, + clear=\E[H\E[2J, + cnorm=\E[?12l\E[?25h, + colors#8, + cols#80, + cr=^M, + csr=\E[%i%p1%d;%p2%dr, + cub=\E[%p1%dD, + cub1=^H, + cud1=^J, + cud=\E[%p1%dB, + cuf1=\E[C, + cuf=\E[%p1%dC, + cup=\E[%i%p1%d;%p2%dH, + cuu1=\E[A, + cuu=\E[%p1%dA, + dch=\E[%p1%dP, + dch1=\E[P, + dim=\E[2m, + dl=\E[%p1%dM, + dl1=\E[M, + ech=\E[%p1%dX, + ed=\E[J, + el=\E[K, + el1=\E[1K, + enacs=\E)0, + flash=\E[?5h$<80/>\E[?5l, + fsl=^G, + home=\E[H, + hpa=\E[%i%p1%dG, + hs, + ht=^I, + hts=\EH, + ich=\E[%p1%d@, + il1=\E[L, + il=\E[%p1%dL, + ind=^J, + indn=\E[%p1%dS, + invis=\E[8m, + is2=\E[4l\E>\E[?1034l, + it#8, + kel=\E[1;2F, + ked=\E[1;5F, + ka1=\E[1~, + ka3=\E[5~, + kc1=\E[4~, + kc3=\E[6~, + kbs=\177, + kcbt=\E[Z, + kb2=\EOu, + kcub1=\EOD, + kcud1=\EOB, + kcuf1=\EOC, + kcuu1=\EOA, + kDC=\E[3;2~, + kent=\EOM, + kEND=\E[1;2F, + kIC=\E[2;2~, + kNXT=\E[6;2~, + kPRV=\E[5;2~, + kHOM=\E[1;2H, + kLFT=\E[1;2D, + kRIT=\E[1;2C, + kind=\E[1;2B, + kri=\E[1;2A, + kclr=\E[3;5~, + kdl1=\E[3;2~, + kdch1=\E[3~, + kich1=\E[2~, + kend=\E[4~, + kf1=\EOP, + kf2=\EOQ, + kf3=\EOR, + kf4=\EOS, + kf5=\E[15~, + kf6=\E[17~, + kf7=\E[18~, + kf8=\E[19~, + kf9=\E[20~, + kf10=\E[21~, + kf11=\E[23~, + kf12=\E[24~, + kf13=\E[1;2P, + kf14=\E[1;2Q, + kf15=\E[1;2R, + kf16=\E[1;2S, + kf17=\E[15;2~, + kf18=\E[17;2~, + kf19=\E[18;2~, + kf20=\E[19;2~, + kf21=\E[20;2~, + kf22=\E[21;2~, + kf23=\E[23;2~, + kf24=\E[24;2~, + kf25=\E[1;5P, + kf26=\E[1;5Q, + kf27=\E[1;5R, + kf28=\E[1;5S, + kf29=\E[15;5~, + kf30=\E[17;5~, + kf31=\E[18;5~, + kf32=\E[19;5~, + kf33=\E[20;5~, + kf34=\E[21;5~, + kf35=\E[23;5~, + kf36=\E[24;5~, + kf37=\E[1;6P, + kf38=\E[1;6Q, + kf39=\E[1;6R, + kf40=\E[1;6S, + kf41=\E[15;6~, + kf42=\E[17;6~, + kf43=\E[18;6~, + kf44=\E[19;6~, + kf45=\E[20;6~, + kf46=\E[21;6~, + kf47=\E[23;6~, + kf48=\E[24;6~, + kf49=\E[1;3P, + kf50=\E[1;3Q, + kf51=\E[1;3R, + kf52=\E[1;3S, + kf53=\E[15;3~, + kf54=\E[17;3~, + kf55=\E[18;3~, + kf56=\E[19;3~, + kf57=\E[20;3~, + kf58=\E[21;3~, + kf59=\E[23;3~, + kf60=\E[24;3~, + kf61=\E[1;4P, + kf62=\E[1;4Q, + kf63=\E[1;4R, + khome=\E[1~, + kil1=\E[2;5~, + krmir=\E[2;2~, + knp=\E[6~, + kmous=\E[M, + kpp=\E[5~, + lines#24, + mir, + msgr, + npc, + op=\E[39;49m, + pairs#64, + mc0=\E[i, + mc4=\E[4i, + mc5=\E[5i, + rc=\E8, + rev=\E[7m, + ri=\EM, + ritm=\E[23m, + rmacs=\E(B, + rmcup=\E[?1049l, + rmir=\E[4l, + rmkx=\E[?1l\E>, + rmso=\E[27m, + rmul=\E[24m, + rs1=\Ec, + rs2=\E[4l\E>\E[?1034l, + sc=\E7, + setab=\E[4%p1%dm, + setaf=\E[3%p1%dm, + setb=\E[4%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m, + setf=\E[3%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m, + sgr0=\E[0m, + sgr=%?%p9%t\E(0%e\E(B%;\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m, + sitm=\E[3m, + smacs=\E(0, + smcup=\E[?1049h, + smir=\E[4h, + smkx=\E[?1h\E=, + smso=\E[7m, + smul=\E[4m, + tbc=\E[3g, + tsl=\E]0;, + xenl, + vpa=\E[%i%p1%dd, +# XTerm extensions + rmxx=\E[29m, + smxx=\E[9m, +# tmux extensions, see TERMINFO EXTENSIONS in tmux(1) + Tc, + Ms=\E]52;%p1%s;%p2%s\007, + Se=\E[2 q, + Ss=\E[%p1%d q, + +st-256color| simpleterm with 256 colors, + use=st, + ccc, + colors#256, + oc=\E]104\007, + pairs#32767, +# Nicked from xterm-256color + initc=\E]4;%p1%d;rgb\:%p2%{255}%*%{1000}%/%2.2X/%p3%{255}%*%{1000}%/%2.2X/%p4%{255}%*%{1000}%/%2.2X\E\\, + setab=\E[%?%p1%{8}%<%t4%p1%d%e%p1%{16}%<%t10%p1%{8}%-%d%e48;5;%p1%d%;m, + setaf=\E[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m, + +st-meta| simpleterm with meta key, + use=st, + km, + rmm=\E[?1034l, + smm=\E[?1034h, + rs2=\E[4l\E>\E[?1034h, + is2=\E[4l\E>\E[?1034h, + +st-meta-256color| simpleterm with meta key and 256 colors, + use=st-256color, + km, + rmm=\E[?1034l, + smm=\E[?1034h, + rs2=\E[4l\E>\E[?1034h, + is2=\E[4l\E>\E[?1034h, diff --git a/st.o b/st.o new file mode 100644 index 0000000000000000000000000000000000000000..6866e08e575a8aa9fe538ccde7a00422f557d6f1 GIT binary patch literal 80056 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static char *argv0; +#include "arg.h" +#include "st.h" +#include "win.h" + +/* types used in config.h */ +typedef struct { + uint mod; + KeySym keysym; + void (*func)(const Arg *); + const Arg arg; +} Shortcut; + +typedef struct { + uint b; + uint mask; + char *s; +} MouseShortcut; + +typedef struct { + KeySym k; + uint mask; + char *s; + /* three-valued logic variables: 0 indifferent, 1 on, -1 off */ + signed char appkey; /* application keypad */ + signed char appcursor; /* application cursor */ +} Key; + +/* Xresources preferences */ +enum resource_type { + STRING = 0, + INTEGER = 1, + FLOAT = 2 +}; + +typedef struct { + char *name; + enum resource_type type; + void *dst; +} ResourcePref; + +/* X modifiers */ +#define XK_ANY_MOD UINT_MAX +#define XK_NO_MOD 0 +#define XK_SWITCH_MOD (1<<13) + +/* function definitions used in config.h */ +static void clipcopy(const Arg *); +static void clippaste(const Arg *); +static void numlock(const Arg *); +static void selpaste(const Arg *); +static void zoom(const Arg *); +static void zoomabs(const Arg *); +static void zoomreset(const Arg *); + +/* config.h for applying patches and the configuration. */ +#include "config.h" + +/* XEMBED messages */ +#define XEMBED_FOCUS_IN 4 +#define XEMBED_FOCUS_OUT 5 + +/* macros */ +#define IS_SET(flag) ((win.mode & (flag)) != 0) +#define TRUERED(x) (((x) & 0xff0000) >> 8) +#define TRUEGREEN(x) (((x) & 0xff00)) +#define TRUEBLUE(x) (((x) & 0xff) << 8) + +typedef XftDraw *Draw; +typedef XftColor Color; +typedef XftGlyphFontSpec GlyphFontSpec; + +/* Purely graphic info */ +typedef struct { + int tw, th; /* tty width and height */ + int w, h; /* window width and height */ + int hborderpx, vborderpx; + int ch; /* char height */ + int cw; /* char width */ + int cyo; /* char y offset */ + int mode; /* window state/mode flags */ + int cursor; /* cursor style */ +} TermWindow; + +typedef struct { + Display *dpy; + Colormap cmap; + Window win; + Drawable buf; + GlyphFontSpec *specbuf; /* font spec buffer used for rendering */ + Atom xembed, wmdeletewin, netwmname, netwmpid; + XIM xim; + XIC xic; + Draw draw; + Visual *vis; + XSetWindowAttributes attrs; + int scr; + int isfixed; /* is fixed geometry? */ + int depth; /* bit depth */ + int l, t; /* left and top offset */ + int gm; /* geometry mask */ +} XWindow; + +typedef struct { + Atom xtarget; + char *primary, *clipboard; + struct timespec tclick1; + struct timespec tclick2; +} XSelection; + +/* Font structure */ +#define Font Font_ +typedef struct { + int height; + int width; + int ascent; + int descent; + int badslant; + int badweight; + short lbearing; + short rbearing; + XftFont *match; + FcFontSet *set; + FcPattern *pattern; +} Font; + +/* Drawing Context */ +typedef struct { + Color *col; + size_t collen; + Font font, bfont, ifont, ibfont; + GC gc; +} DC; + +static inline ushort sixd_to_16bit(int); +static int xmakeglyphfontspecs(XftGlyphFontSpec *, const Glyph *, int, int, int); +static void xdrawglyphfontspecs(const XftGlyphFontSpec *, Glyph, int, int, int); +static void xdrawglyph(Glyph, int, int); +static void xclear(int, int, int, int); +static int xgeommasktogravity(int); +static void ximopen(Display *); +static void ximinstantiate(Display *, XPointer, XPointer); +static void ximdestroy(XIM, XPointer, XPointer); +static void xinit(int, int); +static void cresize(int, int); +static void xresize(int, int); +static void xhints(void); +static int xloadcolor(int, const char *, Color *); +static int xloadfont(Font *, FcPattern *); +static void xloadfonts(char *, double); +static int xloadsparefont(FcPattern *, int); +static void xloadsparefonts(void); +static void xunloadfont(Font *); +static void xunloadfonts(void); +static void xsetenv(void); +static void xseturgency(int); +static int evcol(XEvent *); +static int evrow(XEvent *); + +static void expose(XEvent *); +static void visibility(XEvent *); +static void unmap(XEvent *); +static void kpress(XEvent *); +static void cmessage(XEvent *); +static void resize(XEvent *); +static void focus(XEvent *); +static void brelease(XEvent *); +static void bpress(XEvent *); +static void bmotion(XEvent *); +static void propnotify(XEvent *); +static void selnotify(XEvent *); +static void selclear_(XEvent *); +static void selrequest(XEvent *); +static void setsel(char *, Time); +static void mousesel(XEvent *, int); +static void mousereport(XEvent *); +static char *kmap(KeySym, uint); +static int match(uint, uint); + +static void run(void); +static void usage(void); + +static void (*handler[LASTEvent])(XEvent *) = { + [KeyPress] = kpress, + [ClientMessage] = cmessage, + [ConfigureNotify] = resize, + [VisibilityNotify] = visibility, + [UnmapNotify] = unmap, + [Expose] = expose, + [FocusIn] = focus, + [FocusOut] = focus, + [MotionNotify] = bmotion, + [ButtonPress] = bpress, + [ButtonRelease] = brelease, +/* + * Uncomment if you want the selection to disappear when you select something + * different in another window. + */ +/* [SelectionClear] = selclear_, */ + [SelectionNotify] = selnotify, +/* + * PropertyNotify is only turned on when there is some INCR transfer happening + * for the selection retrieval. + */ + [PropertyNotify] = propnotify, + [SelectionRequest] = selrequest, +}; + +/* Globals */ +static DC dc; +static XWindow xw; +static XSelection xsel; +static TermWindow win; + +/* Font Ring Cache */ +enum { + FRC_NORMAL, + FRC_ITALIC, + FRC_BOLD, + FRC_ITALICBOLD +}; + +typedef struct { + XftFont *font; + int flags; + Rune unicodep; +} Fontcache; + +/* Fontcache is an array now. A new font will be appended to the array. */ +static Fontcache *frc = NULL; +static int frclen = 0; +static int frccap = 0; +static char *usedfont = NULL; +static double usedfontsize = 0; +static double defaultfontsize = 0; + +static char *opt_alpha = NULL; +static char *opt_class = NULL; +static char **opt_cmd = NULL; +static char *opt_embed = NULL; +static char *opt_font = NULL; +static char *opt_io = NULL; +static char *opt_line = NULL; +static char *opt_name = NULL; +static char *opt_title = NULL; + +static int oldbutton = 3; /* button event on startup: 3 = release */ + +void +clipcopy(const Arg *dummy) +{ + Atom clipboard; + + free(xsel.clipboard); + xsel.clipboard = NULL; + + if (xsel.primary != NULL) { + xsel.clipboard = xstrdup(xsel.primary); + clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0); + XSetSelectionOwner(xw.dpy, clipboard, xw.win, CurrentTime); + } +} + +void +clippaste(const Arg *dummy) +{ + Atom clipboard; + + clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0); + XConvertSelection(xw.dpy, clipboard, xsel.xtarget, clipboard, + xw.win, CurrentTime); +} + +void +selpaste(const Arg *dummy) +{ + XConvertSelection(xw.dpy, XA_PRIMARY, xsel.xtarget, XA_PRIMARY, + xw.win, CurrentTime); +} + +void +numlock(const Arg *dummy) +{ + win.mode ^= MODE_NUMLOCK; +} + +void +zoom(const Arg *arg) +{ + Arg larg; + + larg.f = usedfontsize + arg->f; + zoomabs(&larg); +} + +void +zoomabs(const Arg *arg) +{ + xunloadfonts(); + xloadfonts(usedfont, arg->f); + xloadsparefonts(); + cresize(0, 0); + redraw(); + xhints(); +} + +void +zoomreset(const Arg *arg) +{ + Arg larg; + + if (defaultfontsize > 0) { + larg.f = defaultfontsize; + zoomabs(&larg); + } +} + +int +evcol(XEvent *e) +{ + int x = e->xbutton.x - win.hborderpx; + LIMIT(x, 0, win.tw - 1); + return x / win.cw; +} + +int +evrow(XEvent *e) +{ + int y = e->xbutton.y - win.vborderpx; + LIMIT(y, 0, win.th - 1); + return y / win.ch; +} + +void +mousesel(XEvent *e, int done) +{ + int type, seltype = SEL_REGULAR; + uint state = e->xbutton.state & ~(Button1Mask | forceselmod); + + for (type = 1; type < LEN(selmasks); ++type) { + if (match(selmasks[type], state)) { + seltype = type; + break; + } + } + selextend(evcol(e), evrow(e), seltype, done); + if (done) + setsel(getsel(), e->xbutton.time); +} + +void +mousereport(XEvent *e) +{ + int len, x = evcol(e), y = evrow(e), + button = e->xbutton.button, state = e->xbutton.state; + char buf[40]; + static int ox, oy; + + /* from urxvt */ + if (e->xbutton.type == MotionNotify) { + if (x == ox && y == oy) + return; + if (!IS_SET(MODE_MOUSEMOTION) && !IS_SET(MODE_MOUSEMANY)) + return; + /* MOUSE_MOTION: no reporting if no button is pressed */ + if (IS_SET(MODE_MOUSEMOTION) && oldbutton == 3) + return; + + button = oldbutton + 32; + ox = x; + oy = y; + } else { + if (!IS_SET(MODE_MOUSESGR) && e->xbutton.type == ButtonRelease) { + button = 3; + } else { + button -= Button1; + if (button >= 3) + button += 64 - 3; + } + if (e->xbutton.type == ButtonPress) { + oldbutton = button; + ox = x; + oy = y; + } else if (e->xbutton.type == ButtonRelease) { + oldbutton = 3; + /* MODE_MOUSEX10: no button release reporting */ + if (IS_SET(MODE_MOUSEX10)) + return; + if (button == 64 || button == 65) + return; + } + } + + if (!IS_SET(MODE_MOUSEX10)) { + button += ((state & ShiftMask ) ? 4 : 0) + + ((state & Mod4Mask ) ? 8 : 0) + + ((state & ControlMask) ? 16 : 0); + } + + if (IS_SET(MODE_MOUSESGR)) { + len = snprintf(buf, sizeof(buf), "\033[<%d;%d;%d%c", + button, x+1, y+1, + e->xbutton.type == ButtonRelease ? 'm' : 'M'); + } else if (x < 223 && y < 223) { + len = snprintf(buf, sizeof(buf), "\033[M%c%c%c", + 32+button, 32+x+1, 32+y+1); + } else { + return; + } + + ttywrite(buf, len, 0); +} + +void +bpress(XEvent *e) +{ + struct timespec now; + MouseShortcut *ms; + MouseKey *mk; + int snap; + + if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forceselmod)) { + mousereport(e); + return; + } + + for (ms = mshortcuts; ms < mshortcuts + LEN(mshortcuts); ms++) { + if (e->xbutton.button == ms->b + && match(ms->mask, e->xbutton.state)) { + ttywrite(ms->s, strlen(ms->s), 1); + return; + } + } + + for (mk = mkeys; mk < mkeys + LEN(mkeys); mk++) { + if (e->xbutton.button == mk->b + && match(mk->mask, e->xbutton.state)) { + mk->func(&mk->arg); + return; + } + } + + if (e->xbutton.button == Button1) { + /* + * If the user clicks below predefined timeouts specific + * snapping behaviour is exposed. + */ + clock_gettime(CLOCK_MONOTONIC, &now); + if (TIMEDIFF(now, xsel.tclick2) <= tripleclicktimeout) { + snap = SNAP_LINE; + } else if (TIMEDIFF(now, xsel.tclick1) <= doubleclicktimeout) { + snap = SNAP_WORD; + } else { + snap = 0; + } + xsel.tclick2 = xsel.tclick1; + xsel.tclick1 = now; + + selstart(evcol(e), evrow(e), snap); + } +} + +void +propnotify(XEvent *e) +{ + XPropertyEvent *xpev; + Atom clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0); + + xpev = &e->xproperty; + if (xpev->state == PropertyNewValue && + (xpev->atom == XA_PRIMARY || + xpev->atom == clipboard)) { + selnotify(e); + } +} + +void +selnotify(XEvent *e) +{ + ulong nitems, ofs, rem; + int format; + uchar *data, *last, *repl; + Atom type, incratom, property = None; + + incratom = XInternAtom(xw.dpy, "INCR", 0); + + ofs = 0; + if (e->type == SelectionNotify) + property = e->xselection.property; + else if (e->type == PropertyNotify) + property = e->xproperty.atom; + + if (property == None) + return; + + do { + if (XGetWindowProperty(xw.dpy, xw.win, property, ofs, + BUFSIZ/4, False, AnyPropertyType, + &type, &format, &nitems, &rem, + &data)) { + fprintf(stderr, "Clipboard allocation failed\n"); + return; + } + + if (e->type == PropertyNotify && nitems == 0 && rem == 0) { + /* + * If there is some PropertyNotify with no data, then + * this is the signal of the selection owner that all + * data has been transferred. We won't need to receive + * PropertyNotify events anymore. + */ + MODBIT(xw.attrs.event_mask, 0, PropertyChangeMask); + XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, + &xw.attrs); + } + + if (type == incratom) { + /* + * Activate the PropertyNotify events so we receive + * when the selection owner does send us the next + * chunk of data. + */ + MODBIT(xw.attrs.event_mask, 1, PropertyChangeMask); + XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, + &xw.attrs); + + /* + * Deleting the property is the transfer start signal. + */ + XDeleteProperty(xw.dpy, xw.win, (int)property); + continue; + } + + /* + * As seen in getsel: + * Line endings are inconsistent in the terminal and GUI world + * copy and pasting. When receiving some selection data, + * replace all '\n' with '\r'. + * FIXME: Fix the computer world. + */ + repl = data; + last = data + nitems * format / 8; + while ((repl = memchr(repl, '\n', last - repl))) { + *repl++ = '\r'; + } + + if (IS_SET(MODE_BRCKTPASTE) && ofs == 0) + ttywrite("\033[200~", 6, 0); + ttywrite((char *)data, nitems * format / 8, 1); + if (IS_SET(MODE_BRCKTPASTE) && rem == 0) + ttywrite("\033[201~", 6, 0); + XFree(data); + /* number of 32-bit chunks returned */ + ofs += nitems * format / 32; + } while (rem > 0); + + /* + * Deleting the property again tells the selection owner to send the + * next data chunk in the property. + */ + XDeleteProperty(xw.dpy, xw.win, (int)property); +} + +void +xclipcopy(void) +{ + clipcopy(NULL); +} + +void +selclear_(XEvent *e) +{ + selclear(); +} + +void +selrequest(XEvent *e) +{ + XSelectionRequestEvent *xsre; + XSelectionEvent xev; + Atom xa_targets, string, clipboard; + char *seltext; + + xsre = (XSelectionRequestEvent *) e; + xev.type = SelectionNotify; + xev.requestor = xsre->requestor; + xev.selection = xsre->selection; + xev.target = xsre->target; + xev.time = xsre->time; + if (xsre->property == None) + xsre->property = xsre->target; + + /* reject */ + xev.property = None; + + xa_targets = XInternAtom(xw.dpy, "TARGETS", 0); + if (xsre->target == xa_targets) { + /* respond with the supported type */ + string = xsel.xtarget; + XChangeProperty(xsre->display, xsre->requestor, xsre->property, + XA_ATOM, 32, PropModeReplace, + (uchar *) &string, 1); + xev.property = xsre->property; + } else if (xsre->target == xsel.xtarget || xsre->target == XA_STRING) { + /* + * xith XA_STRING non ascii characters may be incorrect in the + * requestor. It is not our problem, use utf8. + */ + clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0); + if (xsre->selection == XA_PRIMARY) { + seltext = xsel.primary; + } else if (xsre->selection == clipboard) { + seltext = xsel.clipboard; + } else { + fprintf(stderr, + "Unhandled clipboard selection 0x%lx\n", + xsre->selection); + return; + } + if (seltext != NULL) { + XChangeProperty(xsre->display, xsre->requestor, + xsre->property, xsre->target, + 8, PropModeReplace, + (uchar *)seltext, strlen(seltext)); + xev.property = xsre->property; + } + } + + /* all done, send a notification to the listener */ + if (!XSendEvent(xsre->display, xsre->requestor, 1, 0, (XEvent *) &xev)) + fprintf(stderr, "Error sending SelectionNotify event\n"); +} + +void +setsel(char *str, Time t) +{ + if (!str) + return; + + free(xsel.primary); + xsel.primary = str; + + XSetSelectionOwner(xw.dpy, XA_PRIMARY, xw.win, t); + if (XGetSelectionOwner(xw.dpy, XA_PRIMARY) != xw.win) + selclear(); +} + +void +xsetsel(char *str) +{ + setsel(str, CurrentTime); +} + +void +brelease(XEvent *e) +{ + if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forceselmod)) { + mousereport(e); + return; + } + + if (e->xbutton.button == Button2) + selpaste(NULL); + else if (e->xbutton.button == Button1) + mousesel(e, 1); +} + +void +bmotion(XEvent *e) +{ + if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forceselmod)) { + mousereport(e); + return; + } + + mousesel(e, 0); +} + +void +cresize(int width, int height) +{ + int col, row; + + if (width != 0) + win.w = width; + if (height != 0) + win.h = height; + + col = (win.w - 2 * borderpx) / win.cw; + row = (win.h - 2 * borderpx) / win.ch; + col = MAX(1, col); + row = MAX(1, row); + + win.hborderpx = (win.w - col * win.cw) / 2; + win.vborderpx = (win.h - row * win.ch) / 2; + + tresize(col, row); + xresize(col, row); + ttyresize(win.tw, win.th); +} + +void +xresize(int col, int row) +{ + win.tw = col * win.cw; + win.th = row * win.ch; + + XFreePixmap(xw.dpy, xw.buf); + xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h, + xw.depth); + XftDrawChange(xw.draw, xw.buf); + xclear(0, 0, win.w, win.h); + + /* resize to new width */ + xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec)); +} + +ushort +sixd_to_16bit(int x) +{ + return x == 0 ? 0 : 0x3737 + 0x2828 * x; +} + +int +xloadcolor(int i, const char *name, Color *ncolor) +{ + XRenderColor color = { .alpha = 0xffff }; + + if (!name) { + if (BETWEEN(i, 16, 255)) { /* 256 color */ + if (i < 6*6*6+16) { /* same colors as xterm */ + color.red = sixd_to_16bit( ((i-16)/36)%6 ); + color.green = sixd_to_16bit( ((i-16)/6) %6 ); + color.blue = sixd_to_16bit( ((i-16)/1) %6 ); + } else { /* greyscale */ + color.red = 0x0808 + 0x0a0a * (i - (6*6*6+16)); + color.green = color.blue = color.red; + } + return XftColorAllocValue(xw.dpy, xw.vis, + xw.cmap, &color, ncolor); + } else + name = colorname[i]; + } + + return XftColorAllocName(xw.dpy, xw.vis, xw.cmap, name, ncolor); +} + +void +xloadcols(void) +{ + int i; + static int loaded; + Color *cp; + + if (loaded) { + for (cp = dc.col; cp < &dc.col[dc.collen]; ++cp) + XftColorFree(xw.dpy, xw.vis, xw.cmap, cp); + } else { + dc.collen = MAX(LEN(colorname), 256); + dc.col = xmalloc(dc.collen * sizeof(Color)); + } + + for (i = 0; i < dc.collen; i++) + if (!xloadcolor(i, NULL, &dc.col[i])) { + if (colorname[i]) + die("could not allocate color '%s'\n", colorname[i]); + else + die("could not allocate color %d\n", i); + } + + /* set alpha value of bg color */ + if (opt_alpha) + alpha = strtof(opt_alpha, NULL); + dc.col[defaultbg].color.alpha = (unsigned short)(0xffff * alpha); + dc.col[defaultbg].color.red = + ((unsigned short)(dc.col[defaultbg].color.red * alpha)) & 0xff00; + dc.col[defaultbg].color.green = + ((unsigned short)(dc.col[defaultbg].color.green * alpha)) & 0xff00; + dc.col[defaultbg].color.blue = + ((unsigned short)(dc.col[defaultbg].color.blue * alpha)) & 0xff00; + dc.col[defaultbg].pixel &= 0x00FFFFFF; + dc.col[defaultbg].pixel |= (unsigned char)(0xff * alpha) << 24; + loaded = 1; +} + +int +xsetcolorname(int x, const char *name) +{ + Color ncolor; + + if (!BETWEEN(x, 0, dc.collen)) + return 1; + + if (!xloadcolor(x, name, &ncolor)) + return 1; + + XftColorFree(xw.dpy, xw.vis, xw.cmap, &dc.col[x]); + dc.col[x] = ncolor; + if (x == defaultbg) + dc.col[defaultbg].color.alpha = (unsigned short)(0xffff * alpha); + + return 0; +} + +/* + * Absolute coordinates. + */ +void +xclear(int x1, int y1, int x2, int y2) +{ + XftDrawRect(xw.draw, + &dc.col[IS_SET(MODE_REVERSE)? defaultfg : defaultbg], + x1, y1, x2-x1, y2-y1); +} + +void +xclearwin(void) +{ + xclear(0, 0, win.w, win.h); +} + + +void +xhints(void) +{ + XClassHint class = {opt_name ? opt_name : "st", + opt_class ? opt_class : "St"}; + XWMHints wm = {.flags = InputHint, .input = 1}; + XSizeHints *sizeh; + + sizeh = XAllocSizeHints(); + + sizeh->flags = PSize | PResizeInc | PBaseSize | PMinSize; + sizeh->height = win.h; + sizeh->width = win.w; + sizeh->height_inc = 1; + sizeh->width_inc = 1; + sizeh->base_height = 2 * borderpx; + sizeh->base_width = 2 * borderpx; + sizeh->min_height = win.ch + 2 * borderpx; + sizeh->min_width = win.cw + 2 * borderpx; + if (xw.isfixed) { + sizeh->flags |= PMaxSize; + sizeh->min_width = sizeh->max_width = win.w; + sizeh->min_height = sizeh->max_height = win.h; + } + if (xw.gm & (XValue|YValue)) { + sizeh->flags |= USPosition | PWinGravity; + sizeh->x = xw.l; + sizeh->y = xw.t; + sizeh->win_gravity = xgeommasktogravity(xw.gm); + } + + XSetWMProperties(xw.dpy, xw.win, NULL, NULL, NULL, 0, sizeh, &wm, + &class); + XFree(sizeh); +} + +int +xgeommasktogravity(int mask) +{ + switch (mask & (XNegative|YNegative)) { + case 0: + return NorthWestGravity; + case XNegative: + return NorthEastGravity; + case YNegative: + return SouthWestGravity; + } + + return SouthEastGravity; +} + +int +xloadfont(Font *f, FcPattern *pattern) +{ + FcPattern *configured; + FcPattern *match; + FcResult result; + XGlyphInfo extents; + int wantattr, haveattr; + + /* + * Manually configure instead of calling XftMatchFont + * so that we can use the configured pattern for + * "missing glyph" lookups. + */ + configured = FcPatternDuplicate(pattern); + if (!configured) + return 1; + + FcConfigSubstitute(NULL, configured, FcMatchPattern); + XftDefaultSubstitute(xw.dpy, xw.scr, configured); + + match = FcFontMatch(NULL, configured, &result); + if (!match) { + FcPatternDestroy(configured); + return 1; + } + + if (!(f->match = XftFontOpenPattern(xw.dpy, match))) { + FcPatternDestroy(configured); + FcPatternDestroy(match); + return 1; + } + + if ((XftPatternGetInteger(pattern, "slant", 0, &wantattr) == + XftResultMatch)) { + /* + * Check if xft was unable to find a font with the appropriate + * slant but gave us one anyway. Try to mitigate. + */ + if ((XftPatternGetInteger(f->match->pattern, "slant", 0, + &haveattr) != XftResultMatch) || haveattr < wantattr) { + f->badslant = 1; + fputs("font slant does not match\n", stderr); + } + } + + if ((XftPatternGetInteger(pattern, "weight", 0, &wantattr) == + XftResultMatch)) { + if ((XftPatternGetInteger(f->match->pattern, "weight", 0, + &haveattr) != XftResultMatch) || haveattr != wantattr) { + f->badweight = 1; + fputs("font weight does not match\n", stderr); + } + } + + XftTextExtentsUtf8(xw.dpy, f->match, + (const FcChar8 *) ascii_printable, + strlen(ascii_printable), &extents); + + f->set = NULL; + f->pattern = configured; + + f->ascent = f->match->ascent; + f->descent = f->match->descent; + f->lbearing = 0; + f->rbearing = f->match->max_advance_width; + + f->height = f->ascent + f->descent; + f->width = DIVCEIL(extents.xOff, strlen(ascii_printable)); + + return 0; +} + +void +xloadfonts(char *fontstr, double fontsize) +{ + FcPattern *pattern; + double fontval; + + if (fontstr[0] == '-') + pattern = XftXlfdParse(fontstr, False, False); + else + pattern = FcNameParse((FcChar8 *)fontstr); + + if (!pattern) + die("can't open font %s\n", fontstr); + + if (fontsize > 1) { + FcPatternDel(pattern, FC_PIXEL_SIZE); + FcPatternDel(pattern, FC_SIZE); + FcPatternAddDouble(pattern, FC_PIXEL_SIZE, (double)fontsize); + usedfontsize = fontsize; + } else { + if (FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &fontval) == + FcResultMatch) { + usedfontsize = fontval; + } else if (FcPatternGetDouble(pattern, FC_SIZE, 0, &fontval) == + FcResultMatch) { + usedfontsize = -1; + } else { + /* + * Default font size is 12, if none given. This is to + * have a known usedfontsize value. + */ + FcPatternAddDouble(pattern, FC_PIXEL_SIZE, 12); + usedfontsize = 12; + } + defaultfontsize = usedfontsize; + } + + if (xloadfont(&dc.font, pattern)) + die("can't open font %s\n", fontstr); + + if (usedfontsize < 0) { + FcPatternGetDouble(dc.font.match->pattern, + FC_PIXEL_SIZE, 0, &fontval); + usedfontsize = fontval; + if (fontsize == 0) + defaultfontsize = fontval; + } + + /* Setting character width and height. */ + win.cw = ceilf(dc.font.width * cwscale); + win.ch = ceilf(dc.font.height * chscale); + win.cyo = ceilf(dc.font.height * (chscale - 1) / 2); + + FcPatternDel(pattern, FC_SLANT); + FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC); + if (xloadfont(&dc.ifont, pattern)) + die("can't open font %s\n", fontstr); + + FcPatternDel(pattern, FC_WEIGHT); + FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD); + if (xloadfont(&dc.ibfont, pattern)) + die("can't open font %s\n", fontstr); + + FcPatternDel(pattern, FC_SLANT); + FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ROMAN); + if (xloadfont(&dc.bfont, pattern)) + die("can't open font %s\n", fontstr); + + FcPatternDestroy(pattern); +} + +int +xloadsparefont(FcPattern *pattern, int flags) +{ + FcPattern *match; + FcResult result; + + match = FcFontMatch(NULL, pattern, &result); + if (!match) { + return 1; + } + + if (!(frc[frclen].font = XftFontOpenPattern(xw.dpy, match))) { + FcPatternDestroy(match); + return 1; + } + + frc[frclen].flags = flags; + /* Believe U+0000 glyph will present in each default font */ + frc[frclen].unicodep = 0; + frclen++; + + return 0; +} + +void +xloadsparefonts(void) +{ + FcPattern *pattern; + double sizeshift, fontval; + int fc; + char **fp; + + if (frclen != 0) + die("can't embed spare fonts. cache isn't empty"); + + /* Calculate count of spare fonts */ + fc = sizeof(font2) / sizeof(*font2); + if (fc == 0) + return; + + /* Allocate memory for cache entries. */ + if (frccap < 4 * fc) { + frccap += 4 * fc - frccap; + frc = xrealloc(frc, frccap * sizeof(Fontcache)); + } + + for (fp = font2; fp - font2 < fc; ++fp) { + + if (**fp == '-') + pattern = XftXlfdParse(*fp, False, False); + else + pattern = FcNameParse((FcChar8 *)*fp); + + if (!pattern) + die("can't open spare font %s\n", *fp); + + if (defaultfontsize > 0) { + sizeshift = usedfontsize - defaultfontsize; + if (sizeshift != 0 && + FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &fontval) == + FcResultMatch) { + fontval += sizeshift; + FcPatternDel(pattern, FC_PIXEL_SIZE); + FcPatternDel(pattern, FC_SIZE); + FcPatternAddDouble(pattern, FC_PIXEL_SIZE, fontval); + } + } + + FcPatternAddBool(pattern, FC_SCALABLE, 1); + + FcConfigSubstitute(NULL, pattern, FcMatchPattern); + XftDefaultSubstitute(xw.dpy, xw.scr, pattern); + + if (xloadsparefont(pattern, FRC_NORMAL)) + die("can't open spare font %s\n", *fp); + + FcPatternDel(pattern, FC_SLANT); + FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC); + if (xloadsparefont(pattern, FRC_ITALIC)) + die("can't open spare font %s\n", *fp); + + FcPatternDel(pattern, FC_WEIGHT); + FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD); + if (xloadsparefont(pattern, FRC_ITALICBOLD)) + die("can't open spare font %s\n", *fp); + + FcPatternDel(pattern, FC_SLANT); + FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ROMAN); + if (xloadsparefont(pattern, FRC_BOLD)) + die("can't open spare font %s\n", *fp); + + FcPatternDestroy(pattern); + } +} + +void +xunloadfont(Font *f) +{ + XftFontClose(xw.dpy, f->match); + FcPatternDestroy(f->pattern); + if (f->set) + FcFontSetDestroy(f->set); +} + +void +xunloadfonts(void) +{ + /* Free the loaded fonts in the font cache. */ + while (frclen > 0) + XftFontClose(xw.dpy, frc[--frclen].font); + + xunloadfont(&dc.font); + xunloadfont(&dc.bfont); + xunloadfont(&dc.ifont); + xunloadfont(&dc.ibfont); +} + +void +ximopen(Display *dpy) +{ + XIMCallback destroy = { .client_data = NULL, .callback = ximdestroy }; + + if ((xw.xim = XOpenIM(xw.dpy, NULL, NULL, NULL)) == NULL) { + XSetLocaleModifiers("@im=local"); + if ((xw.xim = XOpenIM(xw.dpy, NULL, NULL, NULL)) == NULL) { + XSetLocaleModifiers("@im="); + if ((xw.xim = XOpenIM(xw.dpy, NULL, NULL, NULL)) == NULL) + die("XOpenIM failed. Could not open input device.\n"); + } + } + if (XSetIMValues(xw.xim, XNDestroyCallback, &destroy, NULL) != NULL) + die("XSetIMValues failed. Could not set input method value.\n"); + xw.xic = XCreateIC(xw.xim, XNInputStyle, XIMPreeditNothing | XIMStatusNothing, + XNClientWindow, xw.win, XNFocusWindow, xw.win, NULL); + if (xw.xic == NULL) + die("XCreateIC failed. Could not obtain input method.\n"); +} + +void +ximinstantiate(Display *dpy, XPointer client, XPointer call) +{ + ximopen(dpy); + XUnregisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL, + ximinstantiate, NULL); +} + +void +ximdestroy(XIM xim, XPointer client, XPointer call) +{ + xw.xim = NULL; + XRegisterIMInstantiateCallback(xw.dpy, NULL, NULL, NULL, + ximinstantiate, NULL); +} + +void +xinit(int cols, int rows) +{ + XGCValues gcvalues; + Cursor cursor; + Window parent; + pid_t thispid = getpid(); + XColor xmousefg, xmousebg; + XWindowAttributes attr; + XVisualInfo vis; + + xw.scr = XDefaultScreen(xw.dpy); + + if (!(opt_embed && (parent = strtol(opt_embed, NULL, 0)))) { + parent = XRootWindow(xw.dpy, xw.scr); + xw.depth = 32; + } else { + XGetWindowAttributes(xw.dpy, parent, &attr); + xw.depth = attr.depth; + } + + XMatchVisualInfo(xw.dpy, xw.scr, xw.depth, TrueColor, &vis); + xw.vis = vis.visual; + + /* font */ + if (!FcInit()) + die("could not init fontconfig.\n"); + + usedfont = (opt_font == NULL)? font : opt_font; + xloadfonts(usedfont, 0); + + /* spare fonts */ + xloadsparefonts(); + + /* colors */ + xw.cmap = XCreateColormap(xw.dpy, parent, xw.vis, None); + xloadcols(); + + /* adjust fixed window geometry */ + win.w = 2 * win.hborderpx + cols * win.cw; + win.h = 2 * win.vborderpx + rows * win.ch; + if (xw.gm & XNegative) + xw.l += DisplayWidth(xw.dpy, xw.scr) - win.w - 2; + if (xw.gm & YNegative) + xw.t += DisplayHeight(xw.dpy, xw.scr) - win.h - 2; + + /* Events */ + xw.attrs.background_pixel = dc.col[defaultbg].pixel; + xw.attrs.border_pixel = dc.col[defaultbg].pixel; + xw.attrs.bit_gravity = NorthWestGravity; + xw.attrs.event_mask = FocusChangeMask | KeyPressMask | KeyReleaseMask + | ExposureMask | VisibilityChangeMask | StructureNotifyMask + | ButtonMotionMask | ButtonPressMask | ButtonReleaseMask; + xw.attrs.colormap = xw.cmap; + + xw.win = XCreateWindow(xw.dpy, parent, xw.l, xw.t, + win.w, win.h, 0, xw.depth, InputOutput, + xw.vis, CWBackPixel | CWBorderPixel | CWBitGravity + | CWEventMask | CWColormap, &xw.attrs); + + memset(&gcvalues, 0, sizeof(gcvalues)); + gcvalues.graphics_exposures = False; + xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h, xw.depth); + dc.gc = XCreateGC(xw.dpy, xw.buf, GCGraphicsExposures, &gcvalues); + XSetForeground(xw.dpy, dc.gc, dc.col[defaultbg].pixel); + XFillRectangle(xw.dpy, xw.buf, dc.gc, 0, 0, win.w, win.h); + + /* font spec buffer */ + xw.specbuf = xmalloc(cols * sizeof(GlyphFontSpec)); + + /* Xft rendering context */ + xw.draw = XftDrawCreate(xw.dpy, xw.buf, xw.vis, xw.cmap); + + /* input methods */ + ximopen(xw.dpy); + + /* white cursor, black outline */ + cursor = XCreateFontCursor(xw.dpy, mouseshape); + XDefineCursor(xw.dpy, xw.win, cursor); + + if (XParseColor(xw.dpy, xw.cmap, colorname[mousefg], &xmousefg) == 0) { + xmousefg.red = 0xffff; + xmousefg.green = 0xffff; + xmousefg.blue = 0xffff; + } + + if (XParseColor(xw.dpy, xw.cmap, colorname[mousebg], &xmousebg) == 0) { + xmousebg.red = 0x0000; + xmousebg.green = 0x0000; + xmousebg.blue = 0x0000; + } + + XRecolorCursor(xw.dpy, cursor, &xmousefg, &xmousebg); + + xw.xembed = XInternAtom(xw.dpy, "_XEMBED", False); + xw.wmdeletewin = XInternAtom(xw.dpy, "WM_DELETE_WINDOW", False); + xw.netwmname = XInternAtom(xw.dpy, "_NET_WM_NAME", False); + XSetWMProtocols(xw.dpy, xw.win, &xw.wmdeletewin, 1); + + xw.netwmpid = XInternAtom(xw.dpy, "_NET_WM_PID", False); + XChangeProperty(xw.dpy, xw.win, xw.netwmpid, XA_CARDINAL, 32, + PropModeReplace, (uchar *)&thispid, 1); + + win.mode = MODE_NUMLOCK; + resettitle(); + XMapWindow(xw.dpy, xw.win); + xhints(); + XSync(xw.dpy, False); + + clock_gettime(CLOCK_MONOTONIC, &xsel.tclick1); + clock_gettime(CLOCK_MONOTONIC, &xsel.tclick2); + xsel.primary = NULL; + xsel.clipboard = NULL; + xsel.xtarget = XInternAtom(xw.dpy, "UTF8_STRING", 0); + if (xsel.xtarget == None) + xsel.xtarget = XA_STRING; + + boxdraw_xinit(xw.dpy, xw.cmap, xw.draw, xw.vis); +} + +int +xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x, int y) +{ + float winx = win.hborderpx + x * win.cw, winy = win.vborderpx + y * win.ch, xp, yp; + ushort mode, prevmode = USHRT_MAX; + Font *font = &dc.font; + int frcflags = FRC_NORMAL; + float runewidth = win.cw; + Rune rune; + FT_UInt glyphidx; + FcResult fcres; + FcPattern *fcpattern, *fontpattern; + FcFontSet *fcsets[] = { NULL }; + FcCharSet *fccharset; + int i, f, numspecs = 0; + + for (i = 0, xp = winx, yp = winy + font->ascent + win.cyo; i < len; ++i) { + /* Fetch rune and mode for current glyph. */ + rune = glyphs[i].u; + mode = glyphs[i].mode; + + /* Skip dummy wide-character spacing. */ + if (mode == ATTR_WDUMMY) + continue; + + /* Determine font for glyph if different from previous glyph. */ + if (prevmode != mode) { + prevmode = mode; + font = &dc.font; + frcflags = FRC_NORMAL; + runewidth = win.cw * ((mode & ATTR_WIDE) ? 2.0f : 1.0f); + if ((mode & ATTR_ITALIC) && (mode & ATTR_BOLD)) { + font = &dc.ibfont; + frcflags = FRC_ITALICBOLD; + } else if (mode & ATTR_ITALIC) { + font = &dc.ifont; + frcflags = FRC_ITALIC; + } else if (mode & ATTR_BOLD) { + font = &dc.bfont; + frcflags = FRC_BOLD; + } + yp = winy + font->ascent + win.cyo; + } + + if (mode & ATTR_BOXDRAW) { + /* minor shoehorning: boxdraw uses only this ushort */ + glyphidx = boxdrawindex(&glyphs[i]); + } else { + /* Lookup character index with default font. */ + glyphidx = XftCharIndex(xw.dpy, font->match, rune); + } + if (glyphidx) { + specs[numspecs].font = font->match; + specs[numspecs].glyph = glyphidx; + specs[numspecs].x = (short)xp; + specs[numspecs].y = (short)yp; + xp += runewidth; + numspecs++; + continue; + } + + /* Fallback on font cache, search the font cache for match. */ + for (f = 0; f < frclen; f++) { + glyphidx = XftCharIndex(xw.dpy, frc[f].font, rune); + /* Everything correct. */ + if (glyphidx && frc[f].flags == frcflags) + break; + /* We got a default font for a not found glyph. */ + if (!glyphidx && frc[f].flags == frcflags + && frc[f].unicodep == rune) { + break; + } + } + + /* Nothing was found. Use fontconfig to find matching font. */ + if (f >= frclen) { + if (!font->set) + font->set = FcFontSort(0, font->pattern, + 1, 0, &fcres); + fcsets[0] = font->set; + + /* + * Nothing was found in the cache. Now use + * some dozen of Fontconfig calls to get the + * font for one single character. + * + * Xft and fontconfig are design failures. + */ + fcpattern = FcPatternDuplicate(font->pattern); + fccharset = FcCharSetCreate(); + + FcCharSetAddChar(fccharset, rune); + FcPatternAddCharSet(fcpattern, FC_CHARSET, + fccharset); + FcPatternAddBool(fcpattern, FC_SCALABLE, 1); + + FcConfigSubstitute(0, fcpattern, + FcMatchPattern); + FcDefaultSubstitute(fcpattern); + + fontpattern = FcFontSetMatch(0, fcsets, 1, + fcpattern, &fcres); + + /* Allocate memory for the new cache entry. */ + if (frclen >= frccap) { + frccap += 16; + frc = xrealloc(frc, frccap * sizeof(Fontcache)); + } + + frc[frclen].font = XftFontOpenPattern(xw.dpy, + fontpattern); + if (!frc[frclen].font) + die("XftFontOpenPattern failed seeking fallback font: %s\n", + strerror(errno)); + frc[frclen].flags = frcflags; + frc[frclen].unicodep = rune; + + glyphidx = XftCharIndex(xw.dpy, frc[frclen].font, rune); + + f = frclen; + frclen++; + + FcPatternDestroy(fcpattern); + FcCharSetDestroy(fccharset); + } + + specs[numspecs].font = frc[f].font; + specs[numspecs].glyph = glyphidx; + specs[numspecs].x = (short)xp; + specs[numspecs].y = (short)yp; + xp += runewidth; + numspecs++; + } + + return numspecs; +} + +void +xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, int y) +{ + int charlen = len * ((base.mode & ATTR_WIDE) ? 2 : 1); + int winx = win.hborderpx + x * win.cw, winy = win.vborderpx + y * win.ch, + width = charlen * win.cw; + Color *fg, *bg, *temp, revfg, revbg, truefg, truebg; + XRenderColor colfg, colbg; + XRectangle r; + + /* Fallback on color display for attributes not supported by the font */ + if (base.mode & ATTR_ITALIC && base.mode & ATTR_BOLD) { + if (dc.ibfont.badslant || dc.ibfont.badweight) + base.fg = defaultattr; + } else if ((base.mode & ATTR_ITALIC && dc.ifont.badslant) || + (base.mode & ATTR_BOLD && dc.bfont.badweight)) { + base.fg = defaultattr; + } + + if (IS_TRUECOL(base.fg)) { + colfg.alpha = 0xffff; + colfg.red = TRUERED(base.fg); + colfg.green = TRUEGREEN(base.fg); + colfg.blue = TRUEBLUE(base.fg); + XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colfg, &truefg); + fg = &truefg; + } else { + fg = &dc.col[base.fg]; + } + + if (IS_TRUECOL(base.bg)) { + colbg.alpha = 0xffff; + colbg.green = TRUEGREEN(base.bg); + colbg.red = TRUERED(base.bg); + colbg.blue = TRUEBLUE(base.bg); + XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colbg, &truebg); + bg = &truebg; + } else { + bg = &dc.col[base.bg]; + } + + if (IS_SET(MODE_REVERSE)) { + if (fg == &dc.col[defaultfg]) { + fg = &dc.col[defaultbg]; + } else { + colfg.red = ~fg->color.red; + colfg.green = ~fg->color.green; + colfg.blue = ~fg->color.blue; + colfg.alpha = fg->color.alpha; + XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colfg, + &revfg); + fg = &revfg; + } + + if (bg == &dc.col[defaultbg]) { + bg = &dc.col[defaultfg]; + } else { + colbg.red = ~bg->color.red; + colbg.green = ~bg->color.green; + colbg.blue = ~bg->color.blue; + colbg.alpha = bg->color.alpha; + XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colbg, + &revbg); + bg = &revbg; + } + } + + if ((base.mode & ATTR_BOLD_FAINT) == ATTR_FAINT) { + colfg.red = fg->color.red / 2; + colfg.green = fg->color.green / 2; + colfg.blue = fg->color.blue / 2; + colfg.alpha = fg->color.alpha; + XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colfg, &revfg); + fg = &revfg; + } + + if (base.mode & ATTR_REVERSE) { + temp = fg; + fg = bg; + bg = temp; + } + + if (base.mode & ATTR_BLINK && win.mode & MODE_BLINK) + fg = bg; + + if (base.mode & ATTR_INVISIBLE) + fg = bg; + + /* Intelligent cleaning up of the borders. */ + if (x == 0) { + xclear(0, (y == 0)? 0 : winy, win.vborderpx, + winy + win.ch + + ((winy + win.ch >= win.vborderpx + win.th)? win.h : 0)); + } + if (winx + width >= win.hborderpx + win.tw) { + xclear(winx + width, (y == 0)? 0 : winy, win.w, + ((winy + win.ch >= win.vborderpx + win.th)? win.h : (winy + win.ch))); + } + if (y == 0) + xclear(winx, 0, winx + width, win.hborderpx); + if (winy + win.ch >= win.vborderpx + win.th) + xclear(winx, winy + win.ch, winx + width, win.h); + + /* Clean up the region we want to draw to. */ + XftDrawRect(xw.draw, bg, winx, winy, width, win.ch); + + /* Set the clip region because Xft is sometimes dirty. */ + r.x = 0; + r.y = 0; + r.height = win.ch; + r.width = width; + XftDrawSetClipRectangles(xw.draw, winx, winy, &r, 1); + + if (base.mode & ATTR_BOXDRAW) { + drawboxes(winx, winy, width / len, win.ch, fg, bg, specs, len); + } else { + /* Render the glyphs. */ + XftDrawGlyphFontSpec(xw.draw, fg, specs, len); + } + + /* Render underline and strikethrough. */ + if (base.mode & ATTR_UNDERLINE) { + XftDrawRect(xw.draw, fg, winx, winy + win.cyo + dc.font.ascent + 1, + width, 1); + } + + if (base.mode & ATTR_STRUCK) { + XftDrawRect(xw.draw, fg, winx, winy + win.cyo + 2 * dc.font.ascent / 3, + width, 1); + } + + /* Reset clip to none. */ + XftDrawSetClip(xw.draw, 0); +} + +void +xdrawglyph(Glyph g, int x, int y) +{ + int numspecs; + XftGlyphFontSpec spec; + + numspecs = xmakeglyphfontspecs(&spec, &g, 1, x, y); + xdrawglyphfontspecs(&spec, g, numspecs, x, y); +} + +void +xdrawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og) +{ + Color drawcol; + + /* remove the old cursor */ + if (selected(ox, oy)) + og.mode ^= ATTR_REVERSE; + xdrawglyph(og, ox, oy); + + if (IS_SET(MODE_HIDE)) + return; + + /* + * Select the right color for the right mode. + */ + g.mode &= ATTR_BOLD|ATTR_ITALIC|ATTR_UNDERLINE|ATTR_STRUCK|ATTR_WIDE|ATTR_BOXDRAW; + + if (IS_SET(MODE_REVERSE)) { + g.mode |= ATTR_REVERSE; + g.bg = defaultfg; + if (selected(cx, cy)) { + drawcol = dc.col[defaultcs]; + g.fg = defaultrcs; + } else { + drawcol = dc.col[defaultrcs]; + g.fg = defaultcs; + } + } else { + if (selected(cx, cy)) { + g.fg = defaultfg; + g.bg = defaultrcs; + } else { + g.fg = defaultbg; + g.bg = defaultcs; + } + drawcol = dc.col[g.bg]; + } + + /* draw the new one */ + if (IS_SET(MODE_FOCUSED)) { + switch (win.cursor) { + case 7: /* st extension: snowman (U+2603) */ + g.u = 0x2603; + case 0: /* Blinking Block */ + case 1: /* Blinking Block (Default) */ + case 2: /* Steady Block */ + xdrawglyph(g, cx, cy); + break; + case 3: /* Blinking Underline */ + case 4: /* Steady Underline */ + XftDrawRect(xw.draw, &drawcol, + win.hborderpx + cx * win.cw, + win.vborderpx + (cy + 1) * win.ch - \ + cursorthickness, + win.cw, cursorthickness); + break; + case 5: /* Blinking bar */ + case 6: /* Steady bar */ + XftDrawRect(xw.draw, &drawcol, + win.hborderpx + cx * win.cw, + win.vborderpx + cy * win.ch, + cursorthickness, win.ch); + break; + } + } else { + XftDrawRect(xw.draw, &drawcol, + win.hborderpx + cx * win.cw, + win.vborderpx + cy * win.ch, + win.cw - 1, 1); + XftDrawRect(xw.draw, &drawcol, + win.hborderpx + cx * win.cw, + win.vborderpx + cy * win.ch, + 1, win.ch - 1); + XftDrawRect(xw.draw, &drawcol, + win.hborderpx + (cx + 1) * win.cw - 1, + win.vborderpx + cy * win.ch, + 1, win.ch - 1); + XftDrawRect(xw.draw, &drawcol, + win.hborderpx + cx * win.cw, + win.vborderpx + (cy + 1) * win.ch - 1, + win.cw, 1); + } +} + +void +xsetenv(void) +{ + char buf[sizeof(long) * 8 + 1]; + + snprintf(buf, sizeof(buf), "%lu", xw.win); + setenv("WINDOWID", buf, 1); +} + +void +xsettitle(char *p) +{ + XTextProperty prop; + DEFAULT(p, opt_title); + + Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle, + &prop); + XSetWMName(xw.dpy, xw.win, &prop); + XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmname); + XFree(prop.value); +} + +int +xstartdraw(void) +{ + return IS_SET(MODE_VISIBLE); +} + +void +xdrawline(Line line, int x1, int y1, int x2) +{ + int i, x, ox, numspecs; + Glyph base, new; + XftGlyphFontSpec *specs = xw.specbuf; + + numspecs = xmakeglyphfontspecs(specs, &line[x1], x2 - x1, x1, y1); + i = ox = 0; + for (x = x1; x < x2 && i < numspecs; x++) { + new = line[x]; + if (new.mode == ATTR_WDUMMY) + continue; + if (selected(x, y1)) + new.mode ^= ATTR_REVERSE; + if (i > 0 && ATTRCMP(base, new)) { + xdrawglyphfontspecs(specs, base, i, ox, y1); + specs += i; + numspecs -= i; + i = 0; + } + if (i == 0) { + ox = x; + base = new; + } + i++; + } + if (i > 0) + xdrawglyphfontspecs(specs, base, i, ox, y1); +} + +void +xfinishdraw(void) +{ + XCopyArea(xw.dpy, xw.buf, xw.win, dc.gc, 0, 0, win.w, + win.h, 0, 0); + XSetForeground(xw.dpy, dc.gc, + dc.col[IS_SET(MODE_REVERSE)? + defaultfg : defaultbg].pixel); +} + +void +xximspot(int x, int y) +{ + XPoint spot = { borderpx + x * win.cw, borderpx + (y + 1) * win.ch }; + XVaNestedList attr = XVaCreateNestedList(0, XNSpotLocation, &spot, NULL); + + XSetICValues(xw.xic, XNPreeditAttributes, attr, NULL); + XFree(attr); +} + +void +expose(XEvent *ev) +{ + redraw(); +} + +void +visibility(XEvent *ev) +{ + XVisibilityEvent *e = &ev->xvisibility; + + MODBIT(win.mode, e->state != VisibilityFullyObscured, MODE_VISIBLE); +} + +void +unmap(XEvent *ev) +{ + win.mode &= ~MODE_VISIBLE; +} + +void +xsetpointermotion(int set) +{ + MODBIT(xw.attrs.event_mask, set, PointerMotionMask); + XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, &xw.attrs); +} + +void +xsetmode(int set, unsigned int flags) +{ + int mode = win.mode; + MODBIT(win.mode, set, flags); + if ((win.mode & MODE_REVERSE) != (mode & MODE_REVERSE)) + redraw(); +} + +int +xsetcursor(int cursor) +{ + DEFAULT(cursor, 1); + if (!BETWEEN(cursor, 0, 6)) + return 1; + win.cursor = cursor; + return 0; +} + +void +xseturgency(int add) +{ + XWMHints *h = XGetWMHints(xw.dpy, xw.win); + + MODBIT(h->flags, add, XUrgencyHint); + XSetWMHints(xw.dpy, xw.win, h); + XFree(h); +} + +void +xbell(void) +{ + if (!(IS_SET(MODE_FOCUSED))) + xseturgency(1); + if (bellvolume) + XkbBell(xw.dpy, xw.win, bellvolume, (Atom)NULL); +} + +void +focus(XEvent *ev) +{ + XFocusChangeEvent *e = &ev->xfocus; + + if (e->mode == NotifyGrab) + return; + + if (ev->type == FocusIn) { + XSetICFocus(xw.xic); + win.mode |= MODE_FOCUSED; + xseturgency(0); + if (IS_SET(MODE_FOCUS)) + ttywrite("\033[I", 3, 0); + } else { + XUnsetICFocus(xw.xic); + win.mode &= ~MODE_FOCUSED; + if (IS_SET(MODE_FOCUS)) + ttywrite("\033[O", 3, 0); + } +} + +int +match(uint mask, uint state) +{ + return mask == XK_ANY_MOD || mask == (state & ~ignoremod); +} + +char* +kmap(KeySym k, uint state) +{ + Key *kp; + int i; + + /* Check for mapped keys out of X11 function keys. */ + for (i = 0; i < LEN(mappedkeys); i++) { + if (mappedkeys[i] == k) + break; + } + if (i == LEN(mappedkeys)) { + if ((k & 0xFFFF) < 0xFD00) + return NULL; + } + + for (kp = key; kp < key + LEN(key); kp++) { + if (kp->k != k) + continue; + + if (!match(kp->mask, state)) + continue; + + if (IS_SET(MODE_APPKEYPAD) ? kp->appkey < 0 : kp->appkey > 0) + continue; + if (IS_SET(MODE_NUMLOCK) && kp->appkey == 2) + continue; + + if (IS_SET(MODE_APPCURSOR) ? kp->appcursor < 0 : kp->appcursor > 0) + continue; + + return kp->s; + } + + return NULL; +} + +void +kpress(XEvent *ev) +{ + XKeyEvent *e = &ev->xkey; + KeySym ksym; + char buf[32], *customkey; + int len; + Rune c; + Status status; + Shortcut *bp; + + if (IS_SET(MODE_KBDLOCK)) + return; + + len = XmbLookupString(xw.xic, e, buf, sizeof buf, &ksym, &status); + /* 1. shortcuts */ + for (bp = shortcuts; bp < shortcuts + LEN(shortcuts); bp++) { + if (ksym == bp->keysym && match(bp->mod, e->state)) { + bp->func(&(bp->arg)); + return; + } + } + + /* 2. custom keys from config.h */ + if ((customkey = kmap(ksym, e->state))) { + ttywrite(customkey, strlen(customkey), 1); + return; + } + + /* 3. composed string from input method */ + if (len == 0) + return; + if (len == 1 && e->state & Mod1Mask) { + if (IS_SET(MODE_8BIT)) { + if (*buf < 0177) { + c = *buf | 0x80; + len = utf8encode(c, buf); + } + } else { + buf[1] = buf[0]; + buf[0] = '\033'; + len = 2; + } + } + ttywrite(buf, len, 1); +} + +void +cmessage(XEvent *e) +{ + /* + * See xembed specs + * http://standards.freedesktop.org/xembed-spec/xembed-spec-latest.html + */ + if (e->xclient.message_type == xw.xembed && e->xclient.format == 32) { + if (e->xclient.data.l[1] == XEMBED_FOCUS_IN) { + win.mode |= MODE_FOCUSED; + xseturgency(0); + } else if (e->xclient.data.l[1] == XEMBED_FOCUS_OUT) { + win.mode &= ~MODE_FOCUSED; + } + } else if (e->xclient.data.l[0] == xw.wmdeletewin) { + ttyhangup(); + exit(0); + } +} + +void +resize(XEvent *e) +{ + if (e->xconfigure.width == win.w && e->xconfigure.height == win.h) + return; + + cresize(e->xconfigure.width, e->xconfigure.height); +} + +void +run(void) +{ + XEvent ev; + int w = win.w, h = win.h; + fd_set rfd; + int xfd = XConnectionNumber(xw.dpy), ttyfd, xev, drawing; + struct timespec seltv, *tv, now, lastblink, trigger; + double timeout; + + /* Waiting for window mapping */ + do { + XNextEvent(xw.dpy, &ev); + /* + * This XFilterEvent call is required because of XOpenIM. It + * does filter out the key event and some client message for + * the input method too. + */ + if (XFilterEvent(&ev, None)) + continue; + if (ev.type == ConfigureNotify) { + w = ev.xconfigure.width; + h = ev.xconfigure.height; + } + } while (ev.type != MapNotify); + + ttyfd = ttynew(opt_line, shell, opt_io, opt_cmd); + cresize(w, h); + + for (timeout = -1, drawing = 0, lastblink = (struct timespec){0};;) { + FD_ZERO(&rfd); + FD_SET(ttyfd, &rfd); + FD_SET(xfd, &rfd); + + if (XPending(xw.dpy)) + timeout = 0; /* existing events might not set xfd */ + + seltv.tv_sec = timeout / 1E3; + seltv.tv_nsec = 1E6 * (timeout - 1E3 * seltv.tv_sec); + tv = timeout >= 0 ? &seltv : NULL; + + if (pselect(MAX(xfd, ttyfd)+1, &rfd, NULL, NULL, tv, NULL) < 0) { + if (errno == EINTR) + continue; + die("select failed: %s\n", strerror(errno)); + } + clock_gettime(CLOCK_MONOTONIC, &now); + + if (FD_ISSET(ttyfd, &rfd)) + ttyread(); + + xev = 0; + while (XPending(xw.dpy)) { + xev = 1; + XNextEvent(xw.dpy, &ev); + if (XFilterEvent(&ev, None)) + continue; + if (handler[ev.type]) + (handler[ev.type])(&ev); + } + + /* + * To reduce flicker and tearing, when new content or event + * triggers drawing, we first wait a bit to ensure we got + * everything, and if nothing new arrives - we draw. + * We start with trying to wait minlatency ms. If more content + * arrives sooner, we retry with shorter and shorter preiods, + * and eventually draw even without idle after maxlatency ms. + * Typically this results in low latency while interacting, + * maximum latency intervals during `cat huge.txt`, and perfect + * sync with periodic updates from animations/key-repeats/etc. + */ + if (FD_ISSET(ttyfd, &rfd) || xev) { + if (!drawing) { + trigger = now; + drawing = 1; + } + timeout = (maxlatency - TIMEDIFF(now, trigger)) \ + / maxlatency * minlatency; + if (timeout > 0) + continue; /* we have time, try to find idle */ + } + + /* idle detected or maxlatency exhausted -> draw */ + timeout = -1; + if (blinktimeout && tattrset(ATTR_BLINK)) { + timeout = blinktimeout - TIMEDIFF(now, lastblink); + if (timeout <= 0) { + if (-timeout > blinktimeout) /* start visible */ + win.mode |= MODE_BLINK; + win.mode ^= MODE_BLINK; + tsetdirtattr(ATTR_BLINK); + lastblink = now; + timeout = blinktimeout; + } + } + + draw(); + XFlush(xw.dpy); + drawing = 0; + } +} + +int +resource_load(XrmDatabase db, char *name, enum resource_type rtype, void *dst) +{ + char **sdst = dst; + int *idst = dst; + float *fdst = dst; + + char fullname[256]; + char fullclass[256]; + char *type; + XrmValue ret; + + snprintf(fullname, sizeof(fullname), "%s.%s", + opt_name ? opt_name : "st", name); + snprintf(fullclass, sizeof(fullclass), "%s.%s", + opt_class ? opt_class : "St", name); + fullname[sizeof(fullname) - 1] = fullclass[sizeof(fullclass) - 1] = '\0'; + + XrmGetResource(db, fullname, fullclass, &type, &ret); + if (ret.addr == NULL || strncmp("String", type, 64)) + return 1; + + switch (rtype) { + case STRING: + *sdst = ret.addr; + break; + case INTEGER: + *idst = strtoul(ret.addr, NULL, 10); + break; + case FLOAT: + *fdst = strtof(ret.addr, NULL); + break; + } + return 0; +} + +void +config_init(void) +{ + char *resm; + XrmDatabase db; + ResourcePref *p; + + XrmInitialize(); + resm = XResourceManagerString(xw.dpy); + if (!resm) + return; + + db = XrmGetStringDatabase(resm); + for (p = resources; p < resources + LEN(resources); p++) + resource_load(db, p->name, p->type, p->dst); +} + +void +usage(void) +{ + die("usage: %s [-aiv] [-c class] [-f font] [-g geometry]" + " [-n name] [-o file]\n" + " [-T title] [-t title] [-w windowid]" + " [[-e] command [args ...]]\n" + " %s [-aiv] [-c class] [-f font] [-g geometry]" + " [-n name] [-o file]\n" + " [-T title] [-t title] [-w windowid] -l line" + " [stty_args ...]\n", argv0, argv0); +} + +int +main(int argc, char *argv[]) +{ + xw.l = xw.t = 0; + xw.isfixed = False; + win.cursor = cursorshape; + + ARGBEGIN { + case 'a': + allowaltscreen = 0; + break; + case 'A': + opt_alpha = EARGF(usage()); + break; + case 'c': + opt_class = EARGF(usage()); + break; + case 'e': + if (argc > 0) + --argc, ++argv; + goto run; + case 'f': + opt_font = EARGF(usage()); + break; + case 'g': + xw.gm = XParseGeometry(EARGF(usage()), + &xw.l, &xw.t, &cols, &rows); + break; + case 'i': + xw.isfixed = 1; + break; + case 'o': + opt_io = EARGF(usage()); + break; + case 'l': + opt_line = EARGF(usage()); + break; + case 'n': + opt_name = EARGF(usage()); + break; + case 't': + case 'T': + opt_title = EARGF(usage()); + break; + case 'w': + opt_embed = EARGF(usage()); + break; + case 'v': + die("%s " VERSION "\n", argv0); + break; + default: + usage(); + } ARGEND; + +run: + if (argc > 0) /* eat all remaining arguments */ + opt_cmd = argv; + + if (!opt_title) + opt_title = (opt_line || !opt_cmd) ? "st" : opt_cmd[0]; + + setlocale(LC_CTYPE, ""); + XSetLocaleModifiers(""); + + if(!(xw.dpy = XOpenDisplay(NULL))) + die("Can't open display\n"); + + config_init(); + cols = MAX(cols, 1); + rows = MAX(rows, 1); + tnew(cols, rows); + xinit(cols, rows); + xsetenv(); + selinit(); + run(); + + return 0; +} diff --git a/x.o b/x.o new file mode 100644 index 0000000000000000000000000000000000000000..eaf024e288d20cc099a6bcf95cf95a43fbc856fb GIT binary patch literal 87192 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 L`)qJuWU=-?0NmBw literal 0 HcmV?d00001