pax_global_header00006660000000000000000000000064134275370270014524gustar00rootroot0000000000000052 comment=75f92eb3489275bfcad901e5ca424134eda6e2f4 stterm-0.8.2/000077500000000000000000000000001342753702700130515ustar00rootroot00000000000000stterm-0.8.2/FAQ000066400000000000000000000157661342753702700134220ustar00rootroot00000000000000## Why does st not handle utmp entries? Use the excellent tool of [utmp](http://git.suckless.org/utmp/) for this task. ## Some _random program_ complains that st is unknown/not recognised/unsupported/whatever! It means that st doesn’t have any terminfo entry on your system. Chances are you did not `make install`. If you just want to test it without installing it, you can manually run `tic -sx st.info`. ## Nothing works, and nothing is said about an unknown terminal! * Some programs just assume they’re running in xterm i.e. they don’t rely on terminfo. What you see is the current state of the “xterm compliance”. * Some programs don’t complain about the lacking st description and default to another terminal. In that case see the question about terminfo. ## I get some weird glitches/visual bug on _random program_! Try launching it with a different TERM: $ TERM=xterm myapp. toe(1) will give you a list of available terminals, but you’ll most likely switch between xterm, st or st-256color. The default value for TERM can be changed in config.h (TNAME). ## How do I scroll back up? Using a terminal multiplexer. * `st -e tmux` using C-b [ * `st -e screen` using C-a ESC ## Why doesn't the Del key work in some programs? Taken from the terminfo manpage: If the terminal has a keypad that transmits codes when the keys are pressed, this information can be given. Note that it is not possible to handle terminals where the keypad only works in local (this applies, for example, to the unshifted HP 2621 keys). If the keypad can be set to transmit or not transmit, give these codes as smkx and rmkx. Otherwise the keypad is assumed to always transmit. In the st case smkx=E[?1hE= and rmkx=E[?1lE>, so it is mandatory that applications which want to test against keypad keys send these sequences. But buggy applications (like bash and irssi, for example) don't do this. A fast solution for them is to use the following command: $ printf '\033[?1h\033=' >/dev/tty or $ tput smkx In the case of bash, readline is used. Readline has a different note in its manpage about this issue: enable-keypad (Off) When set to On, readline will try to enable the application keypad when it is called. Some systems need this to enable arrow keys. Adding this option to your .inputrc will fix the keypad problem for all applications using readline. If you are using zsh, then read the zsh FAQ : It should be noted that the O / [ confusion can occur with other keys such as Home and End. Some systems let you query the key sequences sent by these keys from the system's terminal database, terminfo. Unfortunately, the key sequences given there typically apply to the mode that is not the one zsh uses by default (it's the "application" mode rather than the "raw" mode). Explaining the use of terminfo is outside of the scope of this FAQ, but if you wish to use the key sequences given there you can tell the line editor to turn on "application" mode when it starts and turn it off when it stops: function zle-line-init () { echoti smkx } function zle-line-finish () { echoti rmkx } zle -N zle-line-init zle -N zle-line-finish Putting these lines into your .zshrc will fix the problems. ## How can I use meta in 8bit mode? St supports meta in 8bit mode, but the default terminfo entry doesn't use this capability. If you want it, you have to use the 'st-meta' value in TERM. ## I cannot compile st in OpenBSD OpenBSD lacks librt, despite it being mandatory in POSIX . If you want to compile st for OpenBSD you have to remove -lrt from config.mk, and st will compile without any loss of functionality, because all the functions are included in libc on this platform. ## The Backspace Case St is emulating the Linux way of handling backspace being delete and delete being backspace. This is an issue that was discussed in suckless mailing list . Here is why some old grumpy terminal users wants its backspace to be how he feels it: Well, I am going to comment why I want to change the behaviour of this key. When ASCII was defined in 1968, communication with computers was done using punched cards, or hardcopy terminals (basically a typewriter machine connected with the computer using a serial port). ASCII defines DELETE as 7F, because, in punched-card terms, it means all the holes of the card punched; it is thus a kind of 'physical delete'. In the same way, the BACKSPACE key was a non-destructive backspace, as on a typewriter. So, if you wanted to delete a character, you had to BACKSPACE and then DELETE. Another use of BACKSPACE was to type accented characters, for example 'a BACKSPACE `'. The VT100 had no BACKSPACE key; it was generated using the CONTROL key as another control character (CONTROL key sets to 0 b7 b6 b5, so it converts H (code 0x48) into BACKSPACE (code 0x08)), but it had a DELETE key in a similar position where the BACKSPACE key is located today on common PC keyboards. All the terminal emulators emulated the difference between these keys correctly: the backspace key generated a BACKSPACE (^H) and delete key generated a DELETE (^?). But a problem arose when Linus Torvalds wrote Linux. Unlike earlier terminals, the Linux virtual terminal (the terminal emulator integrated in the kernel) returned a DELETE when backspace was pressed, due to the VT100 having a DELETE key in the same position. This created a lot of problems (see [1] and [2]). Since Linux has become the king, a lot of terminal emulators today generate a DELETE when the backspace key is pressed in order to avoid problems with Linux. The result is that the only way of generating a BACKSPACE on these systems is by using CONTROL + H. (I also think that emacs had an important point here because the CONTROL + H prefix is used in emacs in some commands (help commands).) From point of view of the kernel, you can change the key for deleting a previous character with stty erase. When you connect a real terminal into a machine you describe the type of terminal, so getty configures the correct value of stty erase for this terminal. In the case of terminal emulators, however, you don't have any getty that can set the correct value of stty erase, so you always get the default value. For this reason, it is necessary to add 'stty erase ^H' to your profile if you have changed the value of the backspace key. Of course, another solution is for st itself to modify the value of stty erase. I usually have the inverse problem: when I connect to non-Unix machines, I have to press CONTROL + h to get a BACKSPACE. The inverse problem occurs when a user connects to my Unix machines from a different system with a correct backspace key. [1] http://www.ibb.net/~anne/keyboard.html [2] http://www.tldp.org/HOWTO/Keyboard-and-Console-HOWTO-5.html ## But I really want the old grumpy behaviour of my terminal Apply [1]. [1] http://st.suckless.org/patches/delkey stterm-0.8.2/LEGACY000066400000000000000000000013341342753702700137410ustar00rootroot00000000000000A STATEMENT ON LEGACY SUPPORT In the terminal world there is much cruft that comes from old and unsup‐ ported terminals that inherit incompatible modes and escape sequences which noone is able to know, except when he/she comes from that time and developed a graphical vt100 emulator at that time. One goal of st is to only support what is really needed. When you en‐ counter a sequence which you really need, implement it. But while you are at it, do not add the other cruft you might encounter while sneek‐ ing at other terminal emulators. History has bloated them and there is no real evidence that most of the sequences are used today. Christoph Lohmann <20h@r-36.net> 2012-09-13T07:00:36.081271045+02:00 stterm-0.8.2/LICENSE000066400000000000000000000034521342753702700140620ustar00rootroot00000000000000MIT/X Consortium License © 2014-2018 Hiltjo Posthuma © 2018 Devin J. Pohly © 2014-2017 Quentin Rameau © 2009-2012 Aurélien APTEL © 2008-2017 Anselm R Garbe © 2012-2017 Roberto E. Vargas Caballero © 2012-2016 Christoph Lohmann <20h at r-36 dot net> © 2013 Eon S. Jeon © 2013 Alexander Sedov © 2013 Mark Edgar © 2013-2014 Eric Pruitt © 2013 Michael Forney © 2013-2014 Markus Teich © 2014-2015 Laslo Hunhold Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. stterm-0.8.2/Makefile000066400000000000000000000023561342753702700145170ustar00rootroot00000000000000# st - simple terminal # See LICENSE file for copyright and license details. .POSIX: include config.mk SRC = st.c x.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 $(OBJ): config.h config.mk st: $(OBJ) $(CC) -o $@ $(OBJ) $(STLDFLAGS) clean: rm -f st $(OBJ) st-$(VERSION).tar.gz 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 chmod 755 $(DESTDIR)$(PREFIX)/bin/st 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)$(MANPREFIX)/man1/st.1 .PHONY: all options clean dist install uninstall stterm-0.8.2/README000066400000000000000000000013231342753702700137300ustar00rootroot00000000000000st - simple terminal -------------------- st is a simple terminal emulator for X which sucks less. Requirements ------------ In order to build st you need the Xlib header files. Installation ------------ Edit config.mk to match your local setup (st is installed into the /usr/local namespace by default). Afterwards enter the following command to build and install st (if necessary as root): make clean install Running st ---------- If you did not install st with make clean install, you must compile the st terminfo entry with the following command: tic -sx st.info See the man page for additional details. Credits ------- Based on Aurélien APTEL bt source code. stterm-0.8.2/TODO000066400000000000000000000007121342753702700135410ustar00rootroot00000000000000vt emulation ------------ * double-height support code & interface ---------------- * add a simple way to do multiplexing drawing ------- * add diacritics support to xdraws() * switch to a suckless font drawing library * make the font cache simpler * add better support for brightening of the upper colors bugs ---- * fix shift up/down (shift selection in emacs) * remove DEC test sequence when appropriate misc ---- $ grep -nE 'XXX|TODO' st.c stterm-0.8.2/arg.h000066400000000000000000000020141342753702700137700ustar00rootroot00000000000000/* * 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 stterm-0.8.2/config.def.h000066400000000000000000000472221342753702700152330ustar00rootroot00000000000000/* See LICENSE file for copyright and license details. */ /* * appearance * * font: see http://freedesktop.org/software/fontconfig/fontconfig-user.html */ static char *font = "Liberation Mono:pixelsize=12:antialias=true:autohint=true"; static int borderpx = 2; /* * What program is execed by st depends of these precedence rules: * 1: program passed with -e * 2: utmp option * 3: SHELL environment variable * 4: value of shell in /etc/passwd * 5: value of shell in config.h */ static char *shell = "/bin/sh"; char *utmp = NULL; char *stty_args = "stty raw pass8 nl -echo -iexten -cstopb 38400"; /* identification sequence returned in DA and DECID */ char *vtiden = "\033[?6c"; /* Kerning / character bounding-box multipliers */ static float cwscale = 1.0; static float chscale = 1.0; /* * word delimiter string * * More advanced example: " `'\"()[]{}" */ char *worddelimiters = " "; /* selection timeouts (in milliseconds) */ static unsigned int doubleclicktimeout = 300; static unsigned int tripleclicktimeout = 600; /* alt screens */ int allowaltscreen = 1; /* frames per second st should at maximum draw to the screen */ static unsigned int xfps = 120; static unsigned int actionfps = 30; /* * blinking timeout (set to 0 to disable blinking) for the terminal blinking * attribute. */ static unsigned int blinktimeout = 800; /* * thickness of underline and bar cursors */ static unsigned int cursorthickness = 2; /* * bell volume. It must be a value between -100 and 100. Use 0 for disabling * it */ static int bellvolume = 0; /* default TERM value */ char *termname = "st-256color"; /* * spaces per tab * * When you are changing this value, don't forget to adapt the »it« value in * the st.info and appropriately install the st.info in the environment where * you use this st version. * * it#$tabspaces, * * Secondly make sure your kernel is not expanding tabs. When running `stty * -a` »tab0« should appear. You can tell the terminal to not expand tabs by * running following command: * * stty tabs */ unsigned int tabspaces = 8; /* Terminal colors (16 first used in escape sequence) */ static const char *colorname[] = { /* 8 normal colors */ "black", "red3", "green3", "yellow3", "blue2", "magenta3", "cyan3", "gray90", /* 8 bright colors */ "gray50", "red", "green", "yellow", "#5c5cff", "magenta", "cyan", "white", [255] = 0, /* more colors can be added after 255 to use with DefaultXX */ "#cccccc", "#555555", }; /* * Default colors (colorname index) * foreground, background, cursor, reverse cursor */ unsigned int defaultfg = 7; unsigned int defaultbg = 0; static unsigned int defaultcs = 256; static 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; /* * Internal mouse shortcuts. * Beware that overloading Button1 will disable the selection. */ static MouseShortcut mshortcuts[] = { /* button mask string */ { Button4, XK_ANY_MOD, "\031" }, { Button5, XK_ANY_MOD, "\005" }, }; /* Internal keyboard shortcuts. */ #define MODKEY Mod1Mask #define TERMMOD (ControlMask|ShiftMask) 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} }, { TERMMOD, XK_Home, zoomreset, {.f = 0} }, { TERMMOD, XK_C, clipcopy, {.i = 0} }, { TERMMOD, XK_V, clippaste, {.i = 0} }, { TERMMOD, XK_Y, selpaste, {.i = 0} }, { ShiftMask, XK_Insert, selpaste, {.i = 0} }, { TERMMOD, XK_Num_Lock, numlock, {.i = 0} }, }; /* * 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{|}~"; stterm-0.8.2/config.mk000066400000000000000000000015351342753702700146530ustar00rootroot00000000000000# 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 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 \ `$(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 stterm-0.8.2/st.1000066400000000000000000000067551342753702700135760ustar00rootroot00000000000000.TH ST 1 st\-VERSION .SH NAME st \- simple terminal .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 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 Ctrl-Shift-Page Up Increase font size. .TP .B Ctrl-Shift-Page Down Decrease font size. .TP .B Ctrl-Shift-Home Reset to default font size. .TP .B Ctrl-Shift-y Paste from primary selection (middle mouse button). .TP .B Ctrl-Shift-c Copy the selected text to the clipboard selection. .TP .B Ctrl-Shift-v Paste from the clipboard selection. .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. stterm-0.8.2/st.c000066400000000000000000001543261342753702700136560ustar00rootroot00000000000000/* See LICENSE for license details. */ #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 /* macros */ #define IS_SET(flag) ((term.mode & (flag)) != 0) #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) (utf8strchr(worddelimiters, u) != NULL) enum term_mode { MODE_WRAP = 1 << 0, MODE_INSERT = 1 << 1, MODE_ALTSCREEN = 1 << 2, MODE_CRLF = 1 << 3, MODE_ECHO = 1 << 4, MODE_PRINT = 1 << 5, MODE_UTF8 = 1 << 6, MODE_SIXEL = 1 << 7, }; enum cursor_movement { CURSOR_SAVE, CURSOR_LOAD }; enum cursor_state { CURSOR_DEFAULT = 0, CURSOR_WRAPNEXT = 1, CURSOR_ORIGIN = 2 }; enum charset { CS_GRAPHIC0, CS_GRAPHIC1, CS_UK, CS_USA, CS_MULTI, CS_GER, CS_FIN }; enum escape_state { ESC_START = 1, ESC_CSI = 2, ESC_STR = 4, /* OSC, PM, APC */ ESC_ALTCHARSET = 8, ESC_STR_END = 16, /* a final string was encountered */ ESC_TEST = 32, /* Enter in test mode */ ESC_UTF8 = 64, ESC_DCS =128, }; typedef struct { Glyph attr; /* current char attributes */ int x; int y; char state; } TCursor; typedef struct { int mode; int type; int snap; /* * Selection variables: * nb – normalized coordinates of the beginning of the selection * ne – normalized coordinates of the end of the selection * ob – original coordinates of the beginning of the selection * oe – original coordinates of the end of the selection */ struct { int x, y; } nb, ne, ob, oe; int alt; } Selection; /* Internal representation of the screen */ typedef struct { int row; /* nb row */ int col; /* nb col */ Line *line; /* screen */ Line *alt; /* alternate screen */ int *dirty; /* dirtyness of lines */ TCursor c; /* cursor */ int ocx; /* old cursor col */ int ocy; /* old cursor row */ int top; /* top scroll limit */ int bot; /* bottom scroll limit */ int mode; /* terminal mode flags */ int esc; /* escape state flags */ char trantbl[4]; /* charset table translation */ int charset; /* current charset */ int icharset; /* selected charset for sequence */ int *tabs; } Term; /* CSI Escape sequence structs */ /* ESC '[' [[ [] [;]] []] */ 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); static void tscrolldown(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 char *utf8strchr(char *, Rune); 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]); } char * utf8strchr(char *s, Rune u) { Rune r; size_t i, j, len; len = strlen(s); for (i = 0, j = 0; i < len; i += j) { if (!(j = utf8decode(&s[i], &r, len - i))) break; if (r == u) return &(s[i]); } return NULL; } 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 (term.line[y][i - 1].mode & ATTR_WRAP) return i; while (i > 0 && term.line[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) 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 = &term.line[*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 (!(term.line[yt][xt].mode & ATTR_WRAP)) break; } if (newx >= tlinelen(newy)) break; gp = &term.line[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 (!(term.line[*y-1][term.col-1].mode & ATTR_WRAP)) { break; } } } else if (direction > 0) { for (; *y < term.row-1; *y += direction) { if (!(term.line[*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 = &term.line[y][sel.nb.x]; lastx = sel.ne.x; } else { gp = &term.line[y][sel.nb.y == y ? sel.nb.x : 0]; lastx = (sel.ne.y == y) ? sel.ne.x : term.col-1; } last = &term.line[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; 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 } } }; tresize(col, row); treset(); } void tswapscreen(void) { Line *tmp = term.line; term.line = term.alt; term.alt = tmp; term.mode ^= MODE_ALTSCREEN; tfulldirt(); } void tscrolldown(int orig, int n) { int i; Line temp; LIMIT(n, 0, term.bot-orig+1); 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 i; Line temp; LIMIT(n, 0, term.bot-orig+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); } 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; } 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); } void tdeleteline(int n) { if (BETWEEN(term.c.y, term.top, term.bot)) tscrollup(term.c.y, n); } 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. */ 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]); break; case 'T': /* SD -- Scroll line down */ DEFAULT(csiescseq.arg[0], 1); tscrolldown(term.top, csiescseq.arg[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; 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) { char *dec; dec = base64dec(strescseq.args[2]); if (dec) { xsetsel(dec); xclipcopy(); } else { fprintf(stderr, "erresc: invalid base64\n"); } } return; case 4: /* color set */ if (narg < 3) break; p = strescseq.args[2]; /* FALLTHROUGH */ case 104: /* color reset, here p = NULL */ j = (narg > 1) ? atoi(strescseq.args[1]) : -1; if (xsetcolorname(j, p)) { fprintf(stderr, "erresc: invalid color %s\n", p); } else { /* * TODO if defaultbg color is changed, borders * are dirty */ 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 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); } 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); } 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; 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)); /* 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(term.line[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); 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(); } void redraw(void) { tfulldirt(); draw(); } stterm-0.8.2/st.h000066400000000000000000000053671342753702700136630ustar00rootroot00000000000000/* 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_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; void die(const char *, ...); void redraw(void); void draw(void); 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 *); /* config.h globals */ extern char *utmp; extern char *stty_args; extern char *vtiden; extern char *worddelimiters; extern int allowaltscreen; extern char *termname; extern unsigned int tabspaces; extern unsigned int defaultfg; extern unsigned int defaultbg; stterm-0.8.2/st.info000066400000000000000000000071451342753702700143630ustar00rootroot00000000000000st| 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) Se, Ss, Tc, Ms=\E]52;%p1%s;%p2%s\007, 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, stterm-0.8.2/win.h000066400000000000000000000020171342753702700140170ustar00rootroot00000000000000/* See LICENSE for license details. */ enum win_mode { MODE_VISIBLE = 1 << 0, MODE_FOCUSED = 1 << 1, MODE_APPKEYPAD = 1 << 2, MODE_MOUSEBTN = 1 << 3, MODE_MOUSEMOTION = 1 << 4, MODE_REVERSE = 1 << 5, MODE_KBDLOCK = 1 << 6, MODE_HIDE = 1 << 7, MODE_APPCURSOR = 1 << 8, MODE_MOUSESGR = 1 << 9, MODE_8BIT = 1 << 10, MODE_BLINK = 1 << 11, MODE_FBLINK = 1 << 12, MODE_FOCUS = 1 << 13, MODE_MOUSEX10 = 1 << 14, MODE_MOUSEMANY = 1 << 15, MODE_BRCKTPASTE = 1 << 16, MODE_NUMLOCK = 1 << 17, MODE_MOUSE = MODE_MOUSEBTN|MODE_MOUSEMOTION|MODE_MOUSEX10\ |MODE_MOUSEMANY, }; void xbell(void); void xclipcopy(void); void xdrawcursor(int, int, Glyph, int, int, Glyph); void xdrawline(Line, int, int, int); void xfinishdraw(void); void xloadcols(void); int xsetcolorname(int, const char *); void xsettitle(char *); int xsetcursor(int); void xsetmode(int, unsigned int); void xsetpointermotion(int); void xsetsel(char *); int xstartdraw(void); stterm-0.8.2/x.c000066400000000000000000001261121342753702700134670ustar00rootroot00000000000000/* See LICENSE for license details. */ #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; /* 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 ch; /* char height */ int cw; /* char width */ 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 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 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 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[16]; static int frclen = 0; static char *usedfont = NULL; static double usedfontsize = 0; static double defaultfontsize = 0; 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); 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 - borderpx; LIMIT(x, 0, win.tw - 1); return x / win.cw; } int evrow(XEvent *e) { int y = e->xbutton.y - borderpx; 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; 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; } } 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); 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, DefaultDepth(xw.dpy, xw.scr)); 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); } 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; 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 xhints(void) { XClassHint class = {opt_name ? opt_name : termname, opt_class ? opt_class : termname}; 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 = win.ch; sizeh->width_inc = win.cw; 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); 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); } 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 xinit(int cols, int rows) { XGCValues gcvalues; Cursor cursor; Window parent; pid_t thispid = getpid(); XColor xmousefg, xmousebg; if (!(xw.dpy = XOpenDisplay(NULL))) die("can't open display\n"); xw.scr = XDefaultScreen(xw.dpy); xw.vis = XDefaultVisual(xw.dpy, xw.scr); /* font */ if (!FcInit()) die("could not init fontconfig.\n"); usedfont = (opt_font == NULL)? font : opt_font; xloadfonts(usedfont, 0); /* colors */ xw.cmap = XDefaultColormap(xw.dpy, xw.scr); xloadcols(); /* adjust fixed window geometry */ win.w = 2 * borderpx + cols * win.cw; win.h = 2 * borderpx + 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 | ExposureMask | VisibilityChangeMask | StructureNotifyMask | ButtonMotionMask | ButtonPressMask | ButtonReleaseMask; xw.attrs.colormap = xw.cmap; if (!(opt_embed && (parent = strtol(opt_embed, NULL, 0)))) parent = XRootWindow(xw.dpy, xw.scr); xw.win = XCreateWindow(xw.dpy, parent, xw.l, xw.t, win.w, win.h, 0, XDefaultDepth(xw.dpy, xw.scr), InputOutput, xw.vis, CWBackPixel | CWBorderPixel | CWBitGravity | CWEventMask | CWColormap, &xw.attrs); memset(&gcvalues, 0, sizeof(gcvalues)); gcvalues.graphics_exposures = False; dc.gc = XCreateGC(xw.dpy, parent, GCGraphicsExposures, &gcvalues); xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h, DefaultDepth(xw.dpy, xw.scr)); 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 */ 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"); } } } 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"); /* 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; } int xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x, int y) { float winx = borderpx + x * win.cw, winy = borderpx + 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; 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; } /* 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); /* * Overwrite or create the new cache entry. */ if (frclen >= LEN(frc)) { frclen = LEN(frc) - 1; XftFontClose(xw.dpy, frc[frclen].font); frc[frclen].unicodep = 0; } 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 = borderpx + x * win.cw, winy = borderpx + 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]; } /* Change basic system colors [0-7] to bright system colors [8-15] */ if ((base.mode & ATTR_BOLD_FAINT) == ATTR_BOLD && BETWEEN(base.fg, 0, 7)) fg = &dc.col[base.fg + 8]; 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, borderpx, winy + win.ch + ((winy + win.ch >= borderpx + win.th)? win.h : 0)); } if (winx + width >= borderpx + win.tw) { xclear(winx + width, (y == 0)? 0 : winy, win.w, ((winy + win.ch >= borderpx + win.th)? win.h : (winy + win.ch))); } if (y == 0) xclear(winx, 0, winx + width, borderpx); if (winy + win.ch >= borderpx + 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); /* Render the glyphs. */ XftDrawGlyphFontSpec(xw.draw, fg, specs, len); /* Render underline and strikethrough. */ if (base.mode & ATTR_UNDERLINE) { XftDrawRect(xw.draw, fg, winx, winy + dc.font.ascent + 1, width, 1); } if (base.mode & ATTR_STRUCK) { XftDrawRect(xw.draw, fg, winx, winy + 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; 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, borderpx + cx * win.cw, borderpx + (cy + 1) * win.ch - \ cursorthickness, win.cw, cursorthickness); break; case 5: /* Blinking bar */ case 6: /* Steady bar */ XftDrawRect(xw.draw, &drawcol, borderpx + cx * win.cw, borderpx + cy * win.ch, cursorthickness, win.ch); break; } } else { XftDrawRect(xw.draw, &drawcol, borderpx + cx * win.cw, borderpx + cy * win.ch, win.cw - 1, 1); XftDrawRect(xw.draw, &drawcol, borderpx + cx * win.cw, borderpx + cy * win.ch, 1, win.ch - 1); XftDrawRect(xw.draw, &drawcol, borderpx + (cx + 1) * win.cw - 1, borderpx + cy * win.ch, 1, win.ch - 1); XftDrawRect(xw.draw, &drawcol, borderpx + cx * win.cw, borderpx + (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 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), xev, blinkset = 0, dodraw = 0; int ttyfd; struct timespec drawtimeout, *tv = NULL, now, last, lastblink; long deltatime; /* 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); clock_gettime(CLOCK_MONOTONIC, &last); lastblink = last; for (xev = actionfps;;) { FD_ZERO(&rfd); FD_SET(ttyfd, &rfd); FD_SET(xfd, &rfd); if (pselect(MAX(xfd, ttyfd)+1, &rfd, NULL, NULL, tv, NULL) < 0) { if (errno == EINTR) continue; die("select failed: %s\n", strerror(errno)); } if (FD_ISSET(ttyfd, &rfd)) { ttyread(); if (blinktimeout) { blinkset = tattrset(ATTR_BLINK); if (!blinkset) MODBIT(win.mode, 0, MODE_BLINK); } } if (FD_ISSET(xfd, &rfd)) xev = actionfps; clock_gettime(CLOCK_MONOTONIC, &now); drawtimeout.tv_sec = 0; drawtimeout.tv_nsec = (1000 * 1E6)/ xfps; tv = &drawtimeout; dodraw = 0; if (blinktimeout && TIMEDIFF(now, lastblink) > blinktimeout) { tsetdirtattr(ATTR_BLINK); win.mode ^= MODE_BLINK; lastblink = now; dodraw = 1; } deltatime = TIMEDIFF(now, last); if (deltatime > 1000 / (xev ? xfps : actionfps)) { dodraw = 1; last = now; } if (dodraw) { while (XPending(xw.dpy)) { XNextEvent(xw.dpy, &ev); if (XFilterEvent(&ev, None)) continue; if (handler[ev.type]) (handler[ev.type])(&ev); } draw(); XFlush(xw.dpy); if (xev && !FD_ISSET(xfd, &rfd)) xev--; if (!FD_ISSET(ttyfd, &rfd) && !FD_ISSET(xfd, &rfd)) { if (blinkset) { if (TIMEDIFF(now, lastblink) \ > blinktimeout) { drawtimeout.tv_nsec = 1000; } else { drawtimeout.tv_nsec = (1E6 * \ (blinktimeout - \ TIMEDIFF(now, lastblink))); } drawtimeout.tv_sec = \ drawtimeout.tv_nsec / 1E9; drawtimeout.tv_nsec %= (long)1E9; } else { tv = NULL; } } } } } 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 '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(""); cols = MAX(cols, 1); rows = MAX(rows, 1); tnew(cols, rows); xinit(cols, rows); xsetenv(); selinit(); run(); return 0; }