pax_global_header00006660000000000000000000000064122200747000014504gustar00rootroot0000000000000052 comment=eeae9b0ceef9e2fec4cb4f1132748c302e5ac702 stterm-0.4.1+20130921+giteeae9b0/000077500000000000000000000000001222007470000156335ustar00rootroot00000000000000stterm-0.4.1+20130921+giteeae9b0/FAQ000066400000000000000000000066541222007470000162000ustar00rootroot00000000000000## 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 manualy run `tic -s 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, tive 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, have to 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 $ echo $(tput smkx) >/dev/tty 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 use meta in 8bit mode? St support meta in 8bit mode, but the default terminfo entry doesn't use this capability. If you want it, you have to use st-meta value in TERM. stterm-0.4.1+20130921+giteeae9b0/LEGACY000066400000000000000000000013341222007470000165230ustar00rootroot00000000000000A 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.4.1+20130921+giteeae9b0/LICENSE000066400000000000000000000030731222007470000166430ustar00rootroot00000000000000MIT/X Consortium License © 2009-2012 Aurélien APTEL © 2009 Anselm R Garbe © 2012 Roberto E. Vargas Caballero © 2012 Christoph Lohmann <20h at r-36 dot net> © 2013 Eon S. Jeon © 2013 Alexander Sedov © 2013 Mark Edgar © 2013 Eric Pruitt © 2013 Michael Forney © 2013 Markus Teich 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.4.1+20130921+giteeae9b0/Makefile000066400000000000000000000027251222007470000173010ustar00rootroot00000000000000# st - simple terminal # See LICENSE file for copyright and license details. include config.mk SRC = st.c OBJ = ${SRC:.c=.o} all: options st options: @echo st build options: @echo "CFLAGS = ${CFLAGS}" @echo "LDFLAGS = ${LDFLAGS}" @echo "CC = ${CC}" config.h: cp config.def.h config.h .c.o: @echo CC $< @${CC} -c ${CFLAGS} $< ${OBJ}: config.h config.mk st: ${OBJ} @echo CC -o $@ @${CC} -o $@ ${OBJ} ${LDFLAGS} clean: @echo cleaning @rm -f st ${OBJ} st-${VERSION}.tar.gz dist: clean @echo creating dist tarball @mkdir -p st-${VERSION} @cp -R LICENSE Makefile README config.mk config.def.h st.info st.1 ${SRC} st-${VERSION} @tar -cf st-${VERSION}.tar st-${VERSION} @gzip st-${VERSION}.tar @rm -rf st-${VERSION} install: all @echo installing executable file to ${DESTDIR}${PREFIX}/bin @mkdir -p ${DESTDIR}${PREFIX}/bin @cp -f st ${DESTDIR}${PREFIX}/bin @chmod 755 ${DESTDIR}${PREFIX}/bin/st @echo installing manual page to ${DESTDIR}${MANPREFIX}/man1 @mkdir -p ${DESTDIR}${MANPREFIX}/man1 @sed "s/VERSION/${VERSION}/g" < st.1 > ${DESTDIR}${MANPREFIX}/man1/st.1 @chmod 644 ${DESTDIR}${MANPREFIX}/man1/st.1 @echo Please see the README file regarding the terminfo entry of st. @tic -s st.info uninstall: @echo removing executable file from ${DESTDIR}${PREFIX}/bin @rm -f ${DESTDIR}${PREFIX}/bin/st @echo removing manual page from ${DESTDIR}${MANPREFIX}/man1 @rm -f ${DESTDIR}${MANPREFIX}/man1/st.1 .PHONY: all options clean dist install uninstall stterm-0.4.1+20130921+giteeae9b0/README000066400000000000000000000013321222007470000165120ustar00rootroot00000000000000st - simple terminal -------------------- st is a simple virtual 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 -s st.info See the man page for additional details. Credits ------- Based on Aurélien APTEL bt source code. stterm-0.4.1+20130921+giteeae9b0/TODO000066400000000000000000000011101222007470000163140ustar00rootroot00000000000000vt emulation ------------ * double-height support code & interface ---------------- * clean and complete terminfo entry * add a simple way to do multiplexing drawing ------- * add diacritics support to xdraws() * make the font cache simpler * add hard width handling * xft is reporting wrong width and height for characters bugs ---- * fix shift up/down (shift selection in emacs) * fix selection paste for xatom STRING * fix rows and column definition in fixed geometry * fix -e handling * remove DEC test sequence when appropriate misc ---- $ grep -nE 'XXX|TODO' st.c stterm-0.4.1+20130921+giteeae9b0/arg.h000066400000000000000000000021031222007470000165510ustar00rootroot00000000000000/* * Copy me if you can. * by 20h */ #ifndef __ARG_H__ #define __ARG_H__ extern char *argv0; #define USED(x) ((void)(x)) /* use main(int argc, char *argv[]) */ #define ARGBEGIN for (argv0 = *argv, argv++, argc--;\ argv[0] && argv[0][1]\ && argv[0][0] == '-';\ argc--, argv++) {\ char _argc;\ char **_argv;\ int brk;\ if (argv[0][1] == '-' && argv[0][2] == '\0') {\ argv++;\ argc--;\ break;\ }\ for (brk = 0, argv[0]++, _argv = argv;\ argv[0][0] && !brk;\ argv[0]++) {\ if (_argv != argv)\ break;\ _argc = argv[0][0];\ switch (_argc) #define ARGEND }\ USED(_argc);\ }\ USED(argv);\ USED(argc); #define ARGC() _argc #define EARGF(x) ((argv[0][1] == '\0' && argv[1] == NULL)?\ ((x), abort(), (char *)0) :\ (brk = 1, (argv[0][1] != '\0')?\ (&argv[0][1]) :\ (argc--, argv++, argv[0]))) #define ARGF() ((argv[0][1] == '\0' && argv[1] == NULL)?\ (char *)0 :\ (brk = 1, (argv[0][1] != '\0')?\ (&argv[0][1]) :\ (argc--, argv++, argv[0]))) #endif stterm-0.4.1+20130921+giteeae9b0/config.def.h000066400000000000000000000423521222007470000200140ustar00rootroot00000000000000/* 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=false:autohint=false"; static int borderpx = 2; static char shell[] = "/bin/sh"; /* Kerning / character bounding-box mutlipliers */ float cwscale = 1.0; float chscale = 1.0; /* * word delimiter string * * More advanced example: " `'\"()[]{}" */ static char worddelimiters[] = " "; /* selection timeouts (in milliseconds) */ static unsigned int doubleclicktimeout = 300; static unsigned int tripleclicktimeout = 600; /* alt screens */ static bool allowaltscreen = true; /* 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; /* * bell volume. It must be a value between -100 and 100. Use 0 for disabling * it */ static int bellvolume = 0; /* TERM value */ static char termname[] = "st-256color"; static 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", }; /* * Default colors (colorname index) * foreground, background, cursor */ static unsigned int defaultfg = 7; static unsigned int defaultbg = 0; static unsigned int defaultcs = 256; /* * Colors used, when the specific fg == defaultfg. So in reverse mode this * will reverse too. Another logic would only make the simple feature too * complex. */ static unsigned int defaultitalic = 11; static unsigned int defaultunderline = 7; /* Internal mouse shortcuts. */ /* Beware that overloading Button1 will disable the selection. */ static Mousekey mshortcuts[] = { /* keysym mask string */ { Button4, XK_ANY_MOD, "\031"}, { Button5, XK_ANY_MOD, "\005"}, }; /* Internal keyboard shortcuts. */ #define MODKEY Mod1Mask static Shortcut shortcuts[] = { /* modifier key function argument */ { MODKEY|ShiftMask, XK_Prior, xzoom, {.i = +1} }, { MODKEY|ShiftMask, XK_Next, xzoom, {.i = -1} }, { ShiftMask, XK_Insert, selpaste, {.i = 0} }, { MODKEY|ShiftMask, XK_Insert, clippaste, {.i = 0} }, { MODKEY, 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) * keypad value: * * 0: no value * * > 0: keypad application mode enabled * * = 2: term.numlock = 1 * * < 0: keypad application mode disabled * cursor 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 definitons because st searchs 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 }; /* * Which bits of the state should be ignored. By default the state bit for the * keyboard layout (XK_SWITCH_MOD) is ignored. */ uint ignoremod = XK_SWITCH_MOD; /* key, mask, output, keypad, cursor, crlf */ static Key key[] = { /* keysym mask string keypad cursor crlf */ { XK_KP_Home, ShiftMask, "\033[1;2H", 0, 0, 0}, { XK_KP_Home, XK_ANY_MOD, "\033[H", 0, -1, 0}, { XK_KP_Home, XK_ANY_MOD, "\033[1~", 0, +1, 0}, { XK_KP_Up, XK_ANY_MOD, "\033Ox", +1, 0, 0}, { XK_KP_Up, XK_ANY_MOD, "\033[A", 0, -1, 0}, { XK_KP_Up, XK_ANY_MOD, "\033OA", 0, +1, 0}, { XK_KP_Down, XK_ANY_MOD, "\033Or", +1, 0, 0}, { XK_KP_Down, XK_ANY_MOD, "\033[B", 0, -1, 0}, { XK_KP_Down, XK_ANY_MOD, "\033OB", 0, +1, 0}, { XK_KP_Left, XK_ANY_MOD, "\033Ot", +1, 0, 0}, { XK_KP_Left, XK_ANY_MOD, "\033[D", 0, -1, 0}, { XK_KP_Left, XK_ANY_MOD, "\033OD", 0, +1, 0}, { XK_KP_Right, XK_ANY_MOD, "\033Ov", +1, 0, 0}, { XK_KP_Right, XK_ANY_MOD, "\033[C", 0, -1, 0}, { XK_KP_Right, XK_ANY_MOD, "\033OC", 0, +1, 0}, { XK_KP_Prior, ShiftMask, "\033[5;2~", 0, 0, 0}, { XK_KP_Prior, XK_ANY_MOD, "\033[5~", 0, 0, 0}, { XK_KP_Begin, XK_ANY_MOD, "\033[E", 0, 0, 0}, { XK_KP_End, ControlMask, "\033[J", -1, 0, 0}, { XK_KP_End, ControlMask, "\033[1;5F", +1, 0, 0}, { XK_KP_End, ShiftMask, "\033[K", -1, 0, 0}, { XK_KP_End, ShiftMask, "\033[1;2F", +1, 0, 0}, { XK_KP_End, XK_ANY_MOD, "\033[4~", 0, 0, 0}, { XK_KP_Next, ShiftMask, "\033[6;2~", 0, 0, 0}, { XK_KP_Next, XK_ANY_MOD, "\033[6~", 0, 0, 0}, { XK_KP_Insert, ShiftMask, "\033[2;2~", +1, 0, 0}, { XK_KP_Insert, ShiftMask, "\033[4l", -1, 0, 0}, { XK_KP_Insert, ControlMask, "\033[L", -1, 0, 0}, { XK_KP_Insert, ControlMask, "\033[2;5~", +1, 0, 0}, { XK_KP_Insert, XK_ANY_MOD, "\033[4h", -1, 0, 0}, { XK_KP_Insert, XK_ANY_MOD, "\033[2~", +1, 0, 0}, { XK_KP_Delete, ControlMask, "\033[2J", -1, 0, 0}, { XK_KP_Delete, ControlMask, "\033[3;5~", +1, 0, 0}, { XK_KP_Delete, ShiftMask, "\033[2K", +1, 0, 0}, { XK_KP_Delete, ShiftMask, "\033[3;2~", -1, 0, 0}, { XK_KP_Delete, XK_ANY_MOD, "\033[P", -1, 0, 0}, { XK_KP_Delete, XK_ANY_MOD, "\033[3~", +1, 0, 0}, { XK_KP_Multiply, XK_ANY_MOD, "\033Oj", +2, 0, 0}, { XK_KP_Add, XK_ANY_MOD, "\033Ok", +2, 0, 0}, { XK_KP_Enter, XK_ANY_MOD, "\033OM", +2, 0, 0}, { XK_KP_Enter, XK_ANY_MOD, "\r", -1, 0, -1}, { XK_KP_Enter, XK_ANY_MOD, "\r\n", -1, 0, +1}, { XK_KP_Subtract, XK_ANY_MOD, "\033Om", +2, 0, 0}, { XK_KP_Decimal, XK_ANY_MOD, "\033On", +2, 0, 0}, { XK_KP_Divide, XK_ANY_MOD, "\033Oo", +2, 0, 0}, { XK_KP_0, XK_ANY_MOD, "\033Op", +2, 0, 0}, { XK_KP_1, XK_ANY_MOD, "\033Oq", +2, 0, 0}, { XK_KP_2, XK_ANY_MOD, "\033Or", +2, 0, 0}, { XK_KP_3, XK_ANY_MOD, "\033Os", +2, 0, 0}, { XK_KP_4, XK_ANY_MOD, "\033Ot", +2, 0, 0}, { XK_KP_5, XK_ANY_MOD, "\033Ou", +2, 0, 0}, { XK_KP_6, XK_ANY_MOD, "\033Ov", +2, 0, 0}, { XK_KP_7, XK_ANY_MOD, "\033Ow", +2, 0, 0}, { XK_KP_8, XK_ANY_MOD, "\033Ox", +2, 0, 0}, { XK_KP_9, XK_ANY_MOD, "\033Oy", +2, 0, 0}, { XK_BackSpace, XK_NO_MOD, "\177", 0, 0, 0}, { XK_Up, ShiftMask, "\033[1;2A", 0, 0, 0}, { XK_Up, ControlMask, "\033[1;5A", 0, 0, 0}, { XK_Up, Mod1Mask, "\033[1;3A", 0, 0, 0}, { XK_Up, XK_ANY_MOD, "\033[A", 0, -1, 0}, { XK_Up, XK_ANY_MOD, "\033OA", 0, +1, 0}, { XK_Down, ShiftMask, "\033[1;2B", 0, 0, 0}, { XK_Down, ControlMask, "\033[1;5B", 0, 0, 0}, { XK_Down, Mod1Mask, "\033[1;3B", 0, 0, 0}, { XK_Down, XK_ANY_MOD, "\033[B", 0, -1, 0}, { XK_Down, XK_ANY_MOD, "\033OB", 0, +1, 0}, { XK_Left, ShiftMask, "\033[1;2D", 0, 0, 0}, { XK_Left, ControlMask, "\033[1;5D", 0, 0, 0}, { XK_Left, Mod1Mask, "\033[1;3D", 0, 0, 0}, { XK_Left, XK_ANY_MOD, "\033[D", 0, -1, 0}, { XK_Left, XK_ANY_MOD, "\033OD", 0, +1, 0}, { XK_Right, ShiftMask, "\033[1;2C", 0, 0, 0}, { XK_Right, ControlMask, "\033[1;5C", 0, 0, 0}, { XK_Right, Mod1Mask, "\033[1;3C", 0, 0, 0}, { XK_Right, XK_ANY_MOD, "\033[C", 0, -1, 0}, { XK_Right, XK_ANY_MOD, "\033OC", 0, +1, 0}, { XK_ISO_Left_Tab, ShiftMask, "\033[Z", 0, 0, 0}, { XK_Return, Mod1Mask, "\033\r", 0, 0, -1}, { XK_Return, Mod1Mask, "\033\r\n", 0, 0, +1}, { XK_Return, XK_ANY_MOD, "\r", 0, 0, -1}, { XK_Return, XK_ANY_MOD, "\r\n", 0, 0, +1}, { XK_Insert, ShiftMask, "\033[4l", -1, 0, 0}, { XK_Insert, ShiftMask, "\033[2;2~", +1, 0, 0}, { XK_Insert, ControlMask, "\033[L", -1, 0, 0}, { XK_Insert, ControlMask, "\033[2;5~", +1, 0, 0}, { XK_Insert, XK_ANY_MOD, "\033[4h", -1, 0, 0}, { XK_Insert, XK_ANY_MOD, "\033[2~", +1, 0, 0}, { XK_Delete, ControlMask, "\033[2J", -1, 0, 0}, { XK_Delete, ControlMask, "\033[3;5~", +1, 0, 0}, { XK_Delete, ShiftMask, "\033[2K", +1, 0, 0}, { XK_Delete, ShiftMask, "\033[3;2~", -1, 0, 0}, { XK_Delete, XK_ANY_MOD, "\033[P", -1, 0, 0}, { XK_Delete, XK_ANY_MOD, "\033[3~", +1, 0, 0}, { XK_Home, ShiftMask, "\033[1;2H", 0, 0, 0}, { XK_Home, XK_ANY_MOD, "\033[H", 0, -1, 0}, { XK_Home, XK_ANY_MOD, "\033[1~", 0, +1, 0}, { XK_End, ControlMask, "\033[J", -1, 0, 0}, { XK_End, ControlMask, "\033[1;5F", +1, 0, 0}, { XK_End, ShiftMask, "\033[K", -1, 0, 0}, { XK_End, ShiftMask, "\033[1;2F", +1, 0, 0}, { XK_End, XK_ANY_MOD, "\033[4~", 0, 0, 0}, { XK_Prior, ControlMask, "\033[5;5~", 0, 0, 0}, { XK_Prior, ShiftMask, "\033[5;2~", 0, 0, 0}, { XK_Prior, XK_ANY_MOD, "\033[5~", 0, 0, 0}, { XK_Next, ControlMask, "\033[6;5~", 0, 0, 0}, { XK_Next, ShiftMask, "\033[6;2~", 0, 0, 0}, { XK_Next, XK_ANY_MOD, "\033[6~", 0, 0, 0}, { XK_F1, XK_NO_MOD, "\033OP" , 0, 0, 0}, { XK_F1, /* F13 */ ShiftMask, "\033[1;2P", 0, 0, 0}, { XK_F1, /* F25 */ ControlMask, "\033[1;5P", 0, 0, 0}, { XK_F1, /* F37 */ Mod4Mask, "\033[1;6P", 0, 0, 0}, { XK_F1, /* F49 */ Mod1Mask, "\033[1;3P", 0, 0, 0}, { XK_F1, /* F61 */ Mod3Mask, "\033[1;4P", 0, 0, 0}, { XK_F2, XK_NO_MOD, "\033OQ" , 0, 0, 0}, { XK_F2, /* F14 */ ShiftMask, "\033[1;2Q", 0, 0, 0}, { XK_F2, /* F26 */ ControlMask, "\033[1;5Q", 0, 0, 0}, { XK_F2, /* F38 */ Mod4Mask, "\033[1;6Q", 0, 0, 0}, { XK_F2, /* F50 */ Mod1Mask, "\033[1;3Q", 0, 0, 0}, { XK_F2, /* F62 */ Mod3Mask, "\033[1;4Q", 0, 0, 0}, { XK_F3, XK_NO_MOD, "\033OR" , 0, 0, 0}, { XK_F3, /* F15 */ ShiftMask, "\033[1;2R", 0, 0, 0}, { XK_F3, /* F27 */ ControlMask, "\033[1;5R", 0, 0, 0}, { XK_F3, /* F39 */ Mod4Mask, "\033[1;6R", 0, 0, 0}, { XK_F3, /* F51 */ Mod1Mask, "\033[1;3R", 0, 0, 0}, { XK_F3, /* F63 */ Mod3Mask, "\033[1;4R", 0, 0, 0}, { XK_F4, XK_NO_MOD, "\033OS" , 0, 0, 0}, { XK_F4, /* F16 */ ShiftMask, "\033[1;2S", 0, 0, 0}, { XK_F4, /* F28 */ ShiftMask, "\033[1;5S", 0, 0, 0}, { XK_F4, /* F40 */ Mod4Mask, "\033[1;6S", 0, 0, 0}, { XK_F4, /* F52 */ Mod1Mask, "\033[1;3S", 0, 0, 0}, { XK_F5, XK_NO_MOD, "\033[15~", 0, 0, 0}, { XK_F5, /* F17 */ ShiftMask, "\033[15;2~", 0, 0, 0}, { XK_F5, /* F29 */ ControlMask, "\033[15;5~", 0, 0, 0}, { XK_F5, /* F41 */ Mod4Mask, "\033[15;6~", 0, 0, 0}, { XK_F5, /* F53 */ Mod1Mask, "\033[15;3~", 0, 0, 0}, { XK_F6, XK_NO_MOD, "\033[17~", 0, 0, 0}, { XK_F6, /* F18 */ ShiftMask, "\033[17;2~", 0, 0, 0}, { XK_F6, /* F30 */ ControlMask, "\033[17;5~", 0, 0, 0}, { XK_F6, /* F42 */ Mod4Mask, "\033[17;6~", 0, 0, 0}, { XK_F6, /* F54 */ Mod1Mask, "\033[17;3~", 0, 0, 0}, { XK_F7, XK_NO_MOD, "\033[18~", 0, 0, 0}, { XK_F7, /* F19 */ ShiftMask, "\033[18;2~", 0, 0, 0}, { XK_F7, /* F31 */ ControlMask, "\033[18;5~", 0, 0, 0}, { XK_F7, /* F43 */ Mod4Mask, "\033[18;6~", 0, 0, 0}, { XK_F7, /* F55 */ Mod1Mask, "\033[18;3~", 0, 0, 0}, { XK_F8, XK_NO_MOD, "\033[19~", 0, 0, 0}, { XK_F8, /* F20 */ ShiftMask, "\033[19;2~", 0, 0, 0}, { XK_F8, /* F32 */ ControlMask, "\033[19;5~", 0, 0, 0}, { XK_F8, /* F44 */ Mod4Mask, "\033[19;6~", 0, 0, 0}, { XK_F8, /* F56 */ Mod1Mask, "\033[19;3~", 0, 0, 0}, { XK_F9, XK_NO_MOD, "\033[20~", 0, 0, 0}, { XK_F9, /* F21 */ ShiftMask, "\033[20;2~", 0, 0, 0}, { XK_F9, /* F33 */ ControlMask, "\033[20;5~", 0, 0, 0}, { XK_F9, /* F45 */ Mod4Mask, "\033[20;6~", 0, 0, 0}, { XK_F9, /* F57 */ Mod1Mask, "\033[20;3~", 0, 0, 0}, { XK_F10, XK_NO_MOD, "\033[21~", 0, 0, 0}, { XK_F10, /* F22 */ ShiftMask, "\033[21;2~", 0, 0, 0}, { XK_F10, /* F34 */ ControlMask, "\033[21;5~", 0, 0, 0}, { XK_F10, /* F46 */ Mod4Mask, "\033[21;6~", 0, 0, 0}, { XK_F10, /* F58 */ Mod1Mask, "\033[21;3~", 0, 0, 0}, { XK_F11, XK_NO_MOD, "\033[23~", 0, 0, 0}, { XK_F11, /* F23 */ ShiftMask, "\033[23;2~", 0, 0, 0}, { XK_F11, /* F35 */ ControlMask, "\033[23;5~", 0, 0, 0}, { XK_F11, /* F47 */ Mod4Mask, "\033[23;6~", 0, 0, 0}, { XK_F11, /* F59 */ Mod1Mask, "\033[23;3~", 0, 0, 0}, { XK_F12, XK_NO_MOD, "\033[24~", 0, 0, 0}, { XK_F12, /* F24 */ ShiftMask, "\033[24;2~", 0, 0, 0}, { XK_F12, /* F36 */ ControlMask, "\033[24;5~", 0, 0, 0}, { XK_F12, /* F48 */ Mod4Mask, "\033[24;6~", 0, 0, 0}, { XK_F12, /* F60 */ Mod1Mask, "\033[24;3~", 0, 0, 0}, { XK_F13, XK_NO_MOD, "\033[1;2P", 0, 0, 0}, { XK_F14, XK_NO_MOD, "\033[1;2Q", 0, 0, 0}, { XK_F15, XK_NO_MOD, "\033[1;2R", 0, 0, 0}, { XK_F16, XK_NO_MOD, "\033[1;2S", 0, 0, 0}, { XK_F17, XK_NO_MOD, "\033[15;2~", 0, 0, 0}, { XK_F18, XK_NO_MOD, "\033[17;2~", 0, 0, 0}, { XK_F19, XK_NO_MOD, "\033[18;2~", 0, 0, 0}, { XK_F20, XK_NO_MOD, "\033[19;2~", 0, 0, 0}, { XK_F21, XK_NO_MOD, "\033[20;2~", 0, 0, 0}, { XK_F22, XK_NO_MOD, "\033[21;2~", 0, 0, 0}, { XK_F23, XK_NO_MOD, "\033[23;2~", 0, 0, 0}, { XK_F24, XK_NO_MOD, "\033[24;2~", 0, 0, 0}, { XK_F25, XK_NO_MOD, "\033[1;5P", 0, 0, 0}, { XK_F26, XK_NO_MOD, "\033[1;5Q", 0, 0, 0}, { XK_F27, XK_NO_MOD, "\033[1;5R", 0, 0, 0}, { XK_F28, XK_NO_MOD, "\033[1;5S", 0, 0, 0}, { XK_F29, XK_NO_MOD, "\033[15;5~", 0, 0, 0}, { XK_F30, XK_NO_MOD, "\033[17;5~", 0, 0, 0}, { XK_F31, XK_NO_MOD, "\033[18;5~", 0, 0, 0}, { XK_F32, XK_NO_MOD, "\033[19;5~", 0, 0, 0}, { XK_F33, XK_NO_MOD, "\033[20;5~", 0, 0, 0}, { XK_F34, XK_NO_MOD, "\033[21;5~", 0, 0, 0}, { XK_F35, XK_NO_MOD, "\033[23;5~", 0, 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, }; stterm-0.4.1+20130921+giteeae9b0/config.mk000066400000000000000000000012451222007470000174330ustar00rootroot00000000000000# st version VERSION = 0.4.1 # Customize below to fit your system # paths PREFIX = /usr/local MANPREFIX = ${PREFIX}/share/man X11INC = /usr/X11R6/include X11LIB = /usr/X11R6/lib # includes and libs INCS = -I. -I/usr/include -I${X11INC} \ `pkg-config --cflags fontconfig` \ `pkg-config --cflags freetype2` LIBS = -L/usr/lib -lc -L${X11LIB} -lX11 -lutil -lXext -lXft \ `pkg-config --libs fontconfig` \ `pkg-config --libs freetype2` # flags CPPFLAGS = -DVERSION=\"${VERSION}\" -D_BSD_SOURCE -D_XOPEN_SOURCE=600 CFLAGS += -g -std=c99 -pedantic -Wall -Wvariadic-macros -Os ${INCS} ${CPPFLAGS} LDFLAGS += -g ${LIBS} # compiler and linker CC ?= cc stterm-0.4.1+20130921+giteeae9b0/st.1000066400000000000000000000030541222007470000163450ustar00rootroot00000000000000.TH ST 1 st\-VERSION .SH NAME st \- simple terminal .SH SYNOPSIS .B st .RB [ \-a ] .RB [ \-c .IR class ] .RB [ \-f .IR font ] .RB [ \-g .IR geometry ] .RB [ \-o .IR file ] .RB [ \-t .IR title ] .RB [ \-w .IR windowid ] .RB [ \-v ] .RB [ \-e .IR command ...] .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, which will fixate the height and width of st. The form is [=][{xX}][{+-}{+-}]. See .BR XParseGeometry (3) for further details. .TP .BI \-o " file" writes all the I/O to .I file. 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 \-w " windowid" embeds st within the window identified by .I windowid .TP .B \-v prints version information to stderr, then exits. .TP .BI \-e " program " [ " arguments " "... ]" st executes .I program instead of the shell. If this is used it .B must be the last option on the command line, as in xterm / rxvt. .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) .SH BUGS See the TODO file in the distribution. stterm-0.4.1+20130921+giteeae9b0/st.c000066400000000000000000002454521222007470000164410ustar00rootroot00000000000000/* See LICENSE for licence details. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "arg.h" char *argv0; #define Glyph Glyph_ #define Font Font_ #define Draw XftDraw * #define Colour XftColor #define Colourmap Colormap #define Rectangle XRectangle #if defined(__linux) #include #elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__) #include #elif defined(__FreeBSD__) || defined(__DragonFly__) #include #endif /* XEMBED messages */ #define XEMBED_FOCUS_IN 4 #define XEMBED_FOCUS_OUT 5 /* Arbitrary sizes */ #define UTF_SIZ 4 #define ESC_BUF_SIZ (128*UTF_SIZ) #define ESC_ARG_SIZ 16 #define STR_BUF_SIZ ESC_BUF_SIZ #define STR_ARG_SIZ ESC_ARG_SIZ #define DRAW_BUF_SIZ 20*1024 #define XK_ANY_MOD UINT_MAX #define XK_NO_MOD 0 #define XK_SWITCH_MOD (1<<13) #define REDRAW_TIMEOUT (80*1000) /* 80 ms */ /* macros */ #define SERRNO strerror(errno) #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 DEFAULT(a, b) (a) = (a) ? (a) : (b) #define BETWEEN(x, a, b) ((a) <= (x) && (x) <= (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 IS_SET(flag) ((term.mode & (flag)) != 0) #define TIMEDIFF(t1, t2) ((t1.tv_sec-t2.tv_sec)*1000 + (t1.tv_usec-t2.tv_usec)/1000) #define CEIL(x) (((x) != (int) (x)) ? (x) + 1 : (x)) #define TRUECOLOR(r,g,b) (1 << 24 | (r) << 16 | (g) << 8 | (b)) #define IS_TRUECOL(x) (1 << 24 & (x)) #define TRUERED(x) (((x) & 0xff0000) >> 8) #define TRUEGREEN(x) (((x) & 0xff00)) #define TRUEBLUE(x) (((x) & 0xff) << 8) #define VT102ID "\033[?6c" enum glyph_attribute { ATTR_NULL = 0, ATTR_REVERSE = 1, ATTR_UNDERLINE = 2, ATTR_BOLD = 4, ATTR_GFX = 8, ATTR_ITALIC = 16, ATTR_BLINK = 32, ATTR_WRAP = 64, ATTR_WIDE = 128, ATTR_WDUMMY = 256, }; enum cursor_movement { CURSOR_SAVE, CURSOR_LOAD }; enum cursor_state { CURSOR_DEFAULT = 0, CURSOR_WRAPNEXT = 1, CURSOR_ORIGIN = 2 }; enum term_mode { MODE_WRAP = 1, MODE_INSERT = 2, MODE_APPKEYPAD = 4, MODE_ALTSCREEN = 8, MODE_CRLF = 16, MODE_MOUSEBTN = 32, MODE_MOUSEMOTION = 64, MODE_REVERSE = 128, MODE_KBDLOCK = 256, MODE_HIDE = 512, MODE_ECHO = 1024, MODE_APPCURSOR = 2048, MODE_MOUSESGR = 4096, MODE_8BIT = 8192, MODE_BLINK = 16384, MODE_FBLINK = 32768, MODE_FOCUS = 65536, MODE_MOUSEX10 = 131072, MODE_MOUSEMANY = 262144, MODE_BRCKTPASTE = 524288, MODE_MOUSE = MODE_MOUSEBTN|MODE_MOUSEMOTION|MODE_MOUSEX10\ |MODE_MOUSEMANY, }; enum escape_state { ESC_START = 1, ESC_CSI = 2, ESC_STR = 4, /* DSC, OSC, PM, APC */ ESC_ALTCHARSET = 8, ESC_STR_END = 16, /* a final string was encountered */ ESC_TEST = 32, /* Enter in test mode */ }; enum window_state { WIN_VISIBLE = 1, WIN_REDRAW = 2, WIN_FOCUSED = 4 }; 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 struct { char c[UTF_SIZ]; /* character code */ ushort mode; /* attribute flags */ ulong fg; /* foreground */ ulong bg; /* background */ } Glyph; typedef Glyph *Line; typedef struct { Glyph attr; /* current char attributes */ int x; int y; char state; } TCursor; /* 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; } 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; /* Internal representation of the screen */ typedef struct { int row; /* nb row */ int col; /* nb col */ Line *line; /* screen */ Line *alt; /* alternate screen */ bool *dirty; /* dirtyness of lines */ TCursor c; /* cursor */ int top; /* top scroll limit */ int bot; /* bottom scroll limit */ int mode; /* terminal mode flags */ int esc; /* escape state flags */ bool numlock; /* lock numbers in keyboard */ bool *tabs; } Term; /* Purely graphic info */ typedef struct { Display *dpy; Colourmap cmap; Window win; Drawable buf; Atom xembed, wmdeletewin; XIM xim; XIC xic; Draw draw; Visual *vis; XSetWindowAttributes attrs; int scr; bool isfixed; /* is fixed geometry? */ int fx, fy, fw, fh; /* fixed geometry */ int tw, th; /* tty width and height */ int w, h; /* window width and height */ int ch; /* char height */ int cw; /* char width */ char state; /* focus, redraw, visible */ } XWindow; typedef struct { int b; uint mask; char s[ESC_BUF_SIZ]; } Mousekey; typedef struct { KeySym k; uint mask; char s[ESC_BUF_SIZ]; /* three valued logic variables: 0 indifferent, 1 on, -1 off */ signed char appkey; /* application keypad */ signed char appcursor; /* application cursor */ signed char crlf; /* crlf mode */ } Key; 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; char *clip; Atom xtarget; bool alt; struct timeval tclick1; struct timeval tclick2; } Selection; typedef union { int i; unsigned int ui; float f; const void *v; } Arg; typedef struct { unsigned int mod; KeySym keysym; void (*func)(const Arg *); const Arg arg; } Shortcut; /* function definitions used in config.h */ static void clippaste(const Arg *); static void numlock(const Arg *); static void selpaste(const Arg *); static void xzoom(const Arg *); /* Config.h for applying patches and the configuration. */ #include "config.h" /* Font structure */ typedef struct { int height; int width; int ascent; int descent; short lbearing; short rbearing; XftFont *match; FcFontSet *set; FcPattern *pattern; } Font; /* Drawing Context */ typedef struct { Colour col[LEN(colorname) < 256 ? 256 : LEN(colorname)]; Font font, bfont, ifont, ibfont; GC gc; } DC; static void die(const char *, ...); static void draw(void); static void redraw(int); static void drawregion(int, int, int, int); static void execsh(void); static void sigchld(int); static void run(void); static void csidump(void); static void csihandle(void); static void csiparse(void); static void csireset(void); static void strdump(void); static void strhandle(void); static void strparse(void); static void strreset(void); static int tattrset(int); 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 void tmoveto(int, int); static void tmoveato(int x, int y); static void tnew(int, int); static void tnewline(int); static void tputtab(bool); static void tputc(char *, int); static void treset(void); static int tresize(int, int); static void tscrollup(int, int); static void tscrolldown(int, int); static void tsetattr(int*, int); static void tsetchar(char *, Glyph *, int, int); static void tsetscroll(int, int); static void tswapscreen(void); static void tsetdirt(int, int); static void tsetdirtattr(int); static void tsetmode(bool, bool, int *, int); static void tfulldirt(void); static void techo(char *, int); static long tdefcolor(int *, int *, int); static inline bool match(uint, uint); static void ttynew(void); static void ttyread(void); static void ttyresize(void); static void ttywrite(const char *, size_t); static void xdraws(char *, Glyph, int, int, int, int); static void xhints(void); static void xclear(int, int, int, int); static void xdrawcursor(void); static void xinit(void); static void xloadcols(void); static int xsetcolorname(int, const char *); static int xloadfont(Font *, FcPattern *); static void xloadfonts(char *, int); static int xloadfontset(Font *); static void xsettitle(char *); static void xresettitle(void); static void xsetpointermotion(int); static void xseturgency(int); static void xsetsel(char*); static void xtermclear(int, int, int, int); static void xunloadfont(Font *f); static void xunloadfonts(void); static void xresize(int, int); static void expose(XEvent *); static void visibility(XEvent *); static void unmap(XEvent *); static char *kmap(KeySym, uint); static void kpress(XEvent *); static void cmessage(XEvent *); static void cresize(int, int); static void resize(XEvent *); static void focus(XEvent *); static void brelease(XEvent *); static void bpress(XEvent *); static void bmotion(XEvent *); static void selnotify(XEvent *); static void selclear(XEvent *); static void selrequest(XEvent *); static void selinit(void); static void selsort(void); static inline bool selected(int, int); static void selcopy(void); static void selscroll(int, int); static void selsnap(int, int *, int *, int); static int utf8decode(char *, long *); static int utf8encode(long *, char *); static int utf8size(char *); static int isfullutf8(char *, int); static ssize_t xwrite(int, char *, size_t); static void *xmalloc(size_t); static void *xrealloc(void *, size_t); 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, [SelectionClear] = selclear, [SelectionNotify] = selnotify, [SelectionRequest] = selrequest, }; /* Globals */ static DC dc; static XWindow xw; static Term term; static CSIEscape csiescseq; static STREscape strescseq; static int cmdfd; static pid_t pid; static Selection sel; static int iofd = -1; static char **opt_cmd = NULL; static char *opt_io = NULL; static char *opt_title = NULL; static char *opt_embed = NULL; static char *opt_class = NULL; static char *opt_font = NULL; static int oldbutton = 3; /* button event on startup: 3 = release */ static char *usedfont = NULL; static int usedfontsize = 0; /* Font Ring Cache */ enum { FRC_NORMAL, FRC_ITALIC, FRC_BOLD, FRC_ITALICBOLD }; typedef struct { XftFont *font; int flags; } Fontcache; /* Fontcache is an array now. A new font will be appended to the array. */ static Fontcache frc[16]; static int frclen = 0; ssize_t xwrite(int fd, char *s, size_t len) { size_t aux = len; while(len > 0) { ssize_t r = write(fd, s, len); if(r < 0) return r; len -= r; s += r; } return aux; } void * xmalloc(size_t len) { void *p = malloc(len); if(!p) die("Out of memory\n"); return p; } void * xrealloc(void *p, size_t len) { if((p = realloc(p, len)) == NULL) die("Out of memory\n"); return p; } int utf8decode(char *s, long *u) { uchar c; int i, n, rtn; rtn = 1; c = *s; if(~c & 0x80) { /* 0xxxxxxx */ *u = c; return rtn; } else if((c & 0xE0) == 0xC0) { /* 110xxxxx */ *u = c & 0x1F; n = 1; } else if((c & 0xF0) == 0xE0) { /* 1110xxxx */ *u = c & 0x0F; n = 2; } else if((c & 0xF8) == 0xF0) { /* 11110xxx */ *u = c & 0x07; n = 3; } else { goto invalid; } for(i = n, ++s; i > 0; --i, ++rtn, ++s) { c = *s; if((c & 0xC0) != 0x80) /* 10xxxxxx */ goto invalid; *u <<= 6; *u |= c & 0x3F; } if((n == 1 && *u < 0x80) || (n == 2 && *u < 0x800) || (n == 3 && *u < 0x10000) || (*u >= 0xD800 && *u <= 0xDFFF)) { goto invalid; } return rtn; invalid: *u = 0xFFFD; return rtn; } int utf8encode(long *u, char *s) { uchar *sp; ulong uc; int i, n; sp = (uchar *)s; uc = *u; if(uc < 0x80) { *sp = uc; /* 0xxxxxxx */ return 1; } else if(*u < 0x800) { *sp = (uc >> 6) | 0xC0; /* 110xxxxx */ n = 1; } else if(uc < 0x10000) { *sp = (uc >> 12) | 0xE0; /* 1110xxxx */ n = 2; } else if(uc <= 0x10FFFF) { *sp = (uc >> 18) | 0xF0; /* 11110xxx */ n = 3; } else { goto invalid; } for(i=n,++sp; i>0; --i,++sp) *sp = ((uc >> 6*(i-1)) & 0x3F) | 0x80; /* 10xxxxxx */ return n+1; invalid: /* U+FFFD */ *s++ = '\xEF'; *s++ = '\xBF'; *s = '\xBD'; return 3; } /* use this if your buffer is less than UTF_SIZ, it returns 1 if you can decode UTF-8 otherwise return 0 */ int isfullutf8(char *s, int b) { uchar *c1, *c2, *c3; c1 = (uchar *)s; c2 = (uchar *)++s; c3 = (uchar *)++s; if(b < 1) { return 0; } else if((*c1 & 0xE0) == 0xC0 && b == 1) { return 0; } else if((*c1 & 0xF0) == 0xE0 && ((b == 1) || ((b == 2) && (*c2 & 0xC0) == 0x80))) { return 0; } else if((*c1 & 0xF8) == 0xF0 && ((b == 1) || ((b == 2) && (*c2 & 0xC0) == 0x80) || ((b == 3) && (*c2 & 0xC0) == 0x80 && (*c3 & 0xC0) == 0x80))) { return 0; } else { return 1; } } int utf8size(char *s) { uchar c = *s; if(~c & 0x80) { return 1; } else if((c & 0xE0) == 0xC0) { return 2; } else if((c & 0xF0) == 0xE0) { return 3; } else { return 4; } } static void selinit(void) { memset(&sel.tclick1, 0, sizeof(sel.tclick1)); memset(&sel.tclick2, 0, sizeof(sel.tclick2)); sel.mode = 0; sel.ob.x = -1; sel.clip = NULL; sel.xtarget = XInternAtom(xw.dpy, "UTF8_STRING", 0); if(sel.xtarget == None) sel.xtarget = XA_STRING; } static int x2col(int x) { x -= borderpx; x /= xw.cw; return LIMIT(x, 0, term.col-1); } static int y2row(int y) { y -= borderpx; y /= xw.ch; return LIMIT(y, 0, term.row-1); } static void selsort(void) { if(sel.ob.y == sel.oe.y) { sel.nb.x = MIN(sel.ob.x, sel.oe.x); sel.ne.x = MAX(sel.ob.x, sel.oe.x); } else { 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; } sel.nb.y = MIN(sel.ob.y, sel.oe.y); sel.ne.y = MAX(sel.ob.y, sel.oe.y); } static inline bool selected(int x, int y) { if(sel.ne.y == y && sel.nb.y == y) return BETWEEN(x, sel.nb.x, sel.ne.x); if(sel.type == SEL_RECTANGULAR) { return ((sel.nb.y <= y && y <= sel.ne.y) && (sel.nb.x <= x && x <= sel.ne.x)); } return ((sel.nb.y < y && y < sel.ne.y) || (y == sel.ne.y && x <= sel.ne.x)) || (y == sel.nb.y && x >= sel.nb.x && (x <= sel.ne.x || sel.nb.y != sel.ne.y)); } void selsnap(int mode, int *x, int *y, int direction) { int i; switch(mode) { case SNAP_WORD: /* * Snap around if the word wraps around at the end or * beginning of a line. */ for(;;) { if(direction < 0 && *x <= 0) { if(*y > 0 && term.line[*y - 1][term.col-1].mode & ATTR_WRAP) { *y -= 1; *x = term.col-1; } else { break; } } if(direction > 0 && *x >= term.col-1) { if(*y < term.row-1 && term.line[*y][*x].mode & ATTR_WRAP) { *y += 1; *x = 0; } else { break; } } if(term.line[*y][*x+direction].mode & ATTR_WDUMMY) { *x += direction; continue; } if(strchr(worddelimiters, term.line[*y][*x+direction].c[0])) { break; } *x += direction; } 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 && *y > 0) { for(; *y > 0; *y += direction) { if(!(term.line[*y-1][term.col-1].mode & ATTR_WRAP)) { break; } } } else if(direction > 0 && *y < term.row-1) { for(; *y < term.row; *y += direction) { if(!(term.line[*y][term.col-1].mode & ATTR_WRAP)) { break; } } } break; default: /* * Select the whole line when the end of line is reached. */ if(direction > 0) { i = term.col; while(--i > 0 && term.line[*y][i].c[0] == ' ') /* nothing */; if(i > 0 && i < *x) *x = term.col - 1; } break; } } void getbuttoninfo(XEvent *e) { int type; uint state = e->xbutton.state &~Button1Mask; sel.alt = IS_SET(MODE_ALTSCREEN); sel.oe.x = x2col(e->xbutton.x); sel.oe.y = y2row(e->xbutton.y); if(sel.ob.y < sel.oe.y || (sel.ob.y == sel.oe.y && sel.ob.x < sel.oe.x)) { selsnap(sel.snap, &sel.ob.x, &sel.ob.y, -1); selsnap(sel.snap, &sel.oe.x, &sel.oe.y, +1); } else { selsnap(sel.snap, &sel.oe.x, &sel.oe.y, -1); selsnap(sel.snap, &sel.ob.x, &sel.ob.y, +1); } selsort(); sel.type = SEL_REGULAR; for(type = 1; type < LEN(selmasks); ++type) { if(match(selmasks[type], state)) { sel.type = type; break; } } } void mousereport(XEvent *e) { int x = x2col(e->xbutton.x), y = y2row(e->xbutton.y), button = e->xbutton.button, state = e->xbutton.state, len; char buf[40]; static int 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(!IS_SET(MODE_MOUSEX10)) { button += (state & ShiftMask ? 4 : 0) + (state & Mod4Mask ? 8 : 0) + (state & ControlMask ? 16 : 0); } len = 0; if(IS_SET(MODE_MOUSESGR)) { len = snprintf(buf, sizeof(buf), "\033[<%d;%d;%d%c", button, x+1, y+1, e->xbutton.type == ButtonRelease ? 'm' : 'M'); } else if(x < 223 && y < 223) { len = snprintf(buf, sizeof(buf), "\033[M%c%c%c", 32+button, 32+x+1, 32+y+1); } else { return; } ttywrite(buf, len); } void bpress(XEvent *e) { struct timeval now; Mousekey *mk; if(IS_SET(MODE_MOUSE)) { mousereport(e); return; } for(mk = mshortcuts; mk < mshortcuts + LEN(mshortcuts); mk++) { if(e->xbutton.button == mk->b && match(mk->mask, e->xbutton.state)) { ttywrite(mk->s, strlen(mk->s)); if(IS_SET(MODE_ECHO)) techo(mk->s, strlen(mk->s)); return; } } if(e->xbutton.button == Button1) { gettimeofday(&now, NULL); /* Clear previous selection, logically and visually. */ selclear(NULL); sel.mode = 1; sel.type = SEL_REGULAR; sel.oe.x = sel.ob.x = x2col(e->xbutton.x); sel.oe.y = sel.ob.y = y2row(e->xbutton.y); /* * If the user clicks below predefined timeouts specific * snapping behaviour is exposed. */ if(TIMEDIFF(now, sel.tclick2) <= tripleclicktimeout) { sel.snap = SNAP_LINE; } else if(TIMEDIFF(now, sel.tclick1) <= doubleclicktimeout) { sel.snap = SNAP_WORD; } else { sel.snap = 0; } selsnap(sel.snap, &sel.ob.x, &sel.ob.y, -1); selsnap(sel.snap, &sel.oe.x, &sel.oe.y, +1); selsort(); /* * Draw selection, unless it's regular and we don't want to * make clicks visible */ if(sel.snap != 0) { sel.mode++; tsetdirt(sel.nb.y, sel.ne.y); } sel.tclick2 = sel.tclick1; sel.tclick1 = now; } } void selcopy(void) { char *str, *ptr; int x, y, bufsize, size, i, ex; Glyph *gp, *last; if(sel.ob.x == -1) { str = NULL; } else { 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 + 1; y++) { gp = &term.line[y][0]; last = gp + term.col; while(--last >= gp && !(selected(last - gp, y) && \ strcmp(last->c, " ") != 0)) /* nothing */; for(x = 0; gp <= last; x++, ++gp) { if(!selected(x, y) || (gp->mode & ATTR_WDUMMY)) continue; size = utf8size(gp->c); memcpy(ptr, gp->c, size); ptr += size; } /* * 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 && x > 0 && !((gp-1)->mode & ATTR_WRAP)) *ptr++ = '\n'; /* * If the last selected line expands in the selection * after the visible text '\n' is appended. */ if(y == sel.ne.y) { i = term.col; while(--i > 0 && term.line[y][i].c[0] == ' ') /* nothing */; ex = sel.ne.x; if(sel.nb.y == sel.ne.y && sel.ne.x < sel.nb.x) ex = sel.nb.x; if(i < ex) *ptr++ = '\n'; } } *ptr = 0; } xsetsel(str); } void selnotify(XEvent *e) { ulong nitems, ofs, rem; int format; uchar *data, *last, *repl; Atom type; ofs = 0; do { if(XGetWindowProperty(xw.dpy, xw.win, XA_PRIMARY, ofs, BUFSIZ/4, False, AnyPropertyType, &type, &format, &nitems, &rem, &data)) { fprintf(stderr, "Clipboard allocation failed\n"); return; } /* * As seen in selcopy: * 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)) ttywrite("\033[200~", 6); ttywrite((const char *)data, nitems * format / 8); if(IS_SET(MODE_BRCKTPASTE)) ttywrite("\033[201~", 6); XFree(data); /* number of 32-bit chunks returned */ ofs += nitems * format / 32; } while(rem > 0); } void selpaste(const Arg *dummy) { XConvertSelection(xw.dpy, XA_PRIMARY, sel.xtarget, XA_PRIMARY, xw.win, CurrentTime); } void clippaste(const Arg *dummy) { Atom clipboard; clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0); XConvertSelection(xw.dpy, clipboard, sel.xtarget, XA_PRIMARY, xw.win, CurrentTime); } void selclear(XEvent *e) { if(sel.ob.x == -1) return; sel.ob.x = -1; tsetdirt(sel.nb.y, sel.ne.y); } void selrequest(XEvent *e) { XSelectionRequestEvent *xsre; XSelectionEvent xev; Atom xa_targets, string; xsre = (XSelectionRequestEvent *) e; xev.type = SelectionNotify; xev.requestor = xsre->requestor; xev.selection = xsre->selection; xev.target = xsre->target; xev.time = xsre->time; /* reject */ xev.property = None; xa_targets = XInternAtom(xw.dpy, "TARGETS", 0); if(xsre->target == xa_targets) { /* respond with the supported type */ string = sel.xtarget; XChangeProperty(xsre->display, xsre->requestor, xsre->property, XA_ATOM, 32, PropModeReplace, (uchar *) &string, 1); xev.property = xsre->property; } else if(xsre->target == sel.xtarget && sel.clip != NULL) { XChangeProperty(xsre->display, xsre->requestor, xsre->property, xsre->target, 8, PropModeReplace, (uchar *) sel.clip, strlen(sel.clip)); xev.property = xsre->property; } /* all done, send a notification to the listener */ if(!XSendEvent(xsre->display, xsre->requestor, True, 0, (XEvent *) &xev)) fprintf(stderr, "Error sending SelectionNotify event\n"); } void xsetsel(char *str) { /* register the selection for both the clipboard and the primary */ Atom clipboard; free(sel.clip); sel.clip = str; XSetSelectionOwner(xw.dpy, XA_PRIMARY, xw.win, CurrentTime); clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0); XSetSelectionOwner(xw.dpy, clipboard, xw.win, CurrentTime); } void brelease(XEvent *e) { if(IS_SET(MODE_MOUSE)) { mousereport(e); return; } if(e->xbutton.button == Button2) { selpaste(NULL); } else if(e->xbutton.button == Button1) { if(sel.mode < 2) { selclear(NULL); } else { getbuttoninfo(e); selcopy(); } sel.mode = 0; tsetdirt(sel.nb.y, sel.ne.y); } } void bmotion(XEvent *e) { int oldey, oldex, oldsby, oldsey; if(IS_SET(MODE_MOUSE)) { mousereport(e); return; } if(!sel.mode) return; sel.mode++; oldey = sel.oe.y; oldex = sel.oe.x; oldsby = sel.nb.y; oldsey = sel.ne.y; getbuttoninfo(e); if(oldey != sel.oe.y || oldex != sel.oe.x) tsetdirt(MIN(sel.nb.y, oldsby), MAX(sel.ne.y, oldsey)); } void die(const char *errstr, ...) { va_list ap; va_start(ap, errstr); vfprintf(stderr, errstr, ap); va_end(ap); exit(EXIT_FAILURE); } void execsh(void) { char **args; char *envshell = getenv("SHELL"); const struct passwd *pass = getpwuid(getuid()); char buf[sizeof(long) * 8 + 1]; unsetenv("COLUMNS"); unsetenv("LINES"); unsetenv("TERMCAP"); if(pass) { setenv("LOGNAME", pass->pw_name, 1); setenv("USER", pass->pw_name, 1); setenv("SHELL", pass->pw_shell, 0); setenv("HOME", pass->pw_dir, 0); } snprintf(buf, sizeof(buf), "%lu", xw.win); setenv("WINDOWID", buf, 1); signal(SIGCHLD, SIG_DFL); signal(SIGHUP, SIG_DFL); signal(SIGINT, SIG_DFL); signal(SIGQUIT, SIG_DFL); signal(SIGTERM, SIG_DFL); signal(SIGALRM, SIG_DFL); DEFAULT(envshell, shell); setenv("TERM", termname, 1); args = opt_cmd ? opt_cmd : (char *[]){envshell, "-i", NULL}; execvp(args[0], args); exit(EXIT_FAILURE); } void sigchld(int a) { int stat = 0; if(waitpid(pid, &stat, 0) < 0) die("Waiting for pid %hd failed: %s\n", pid, SERRNO); if(WIFEXITED(stat)) { exit(WEXITSTATUS(stat)); } else { exit(EXIT_FAILURE); } } void ttynew(void) { int m, s; struct winsize w = {term.row, term.col, 0, 0}; /* seems to work fine on linux, openbsd and freebsd */ if(openpty(&m, &s, NULL, NULL, &w) < 0) die("openpty failed: %s\n", SERRNO); switch(pid = fork()) { case -1: die("fork failed\n"); break; case 0: setsid(); /* create a new process group */ dup2(s, STDIN_FILENO); dup2(s, STDOUT_FILENO); dup2(s, STDERR_FILENO); if(ioctl(s, TIOCSCTTY, NULL) < 0) die("ioctl TIOCSCTTY failed: %s\n", SERRNO); close(s); close(m); execsh(); break; default: close(s); cmdfd = m; signal(SIGCHLD, sigchld); if(opt_io) { iofd = (!strcmp(opt_io, "-")) ? STDOUT_FILENO : open(opt_io, O_WRONLY | O_CREAT, 0666); if(iofd < 0) { fprintf(stderr, "Error opening %s:%s\n", opt_io, strerror(errno)); } } } } void dump(char c) { static int col; fprintf(stderr, " %02x '%c' ", c, isprint(c)?c:'.'); if(++col % 10 == 0) fprintf(stderr, "\n"); } void ttyread(void) { static char buf[BUFSIZ]; static int buflen = 0; char *ptr; char s[UTF_SIZ]; int charsize; /* size of utf8 char in bytes */ long utf8c; int ret; /* append read bytes to unprocessed bytes */ if((ret = read(cmdfd, buf+buflen, LEN(buf)-buflen)) < 0) die("Couldn't read from shell: %s\n", SERRNO); /* process every complete utf8 char */ buflen += ret; ptr = buf; while(buflen >= UTF_SIZ || isfullutf8(ptr,buflen)) { charsize = utf8decode(ptr, &utf8c); utf8encode(&utf8c, s); tputc(s, charsize); ptr += charsize; buflen -= charsize; } /* keep any uncomplete utf8 char for the next call */ memmove(buf, ptr, buflen); } void ttywrite(const char *s, size_t n) { if(write(cmdfd, s, n) == -1) die("write error on tty: %s\n", SERRNO); } void ttyresize(void) { struct winsize w; w.ws_row = term.row; w.ws_col = term.col; w.ws_xpixel = xw.tw; w.ws_ypixel = xw.th; if(ioctl(cmdfd, TIOCSWINSZ, &w) < 0) fprintf(stderr, "Couldn't set window size: %s\n", SERRNO); } 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; if(mode == CURSOR_SAVE) { c = term.c; } else if(mode == CURSOR_LOAD) { term.c = c; tmoveto(c.x, c.y); } } void treset(void) { uint i; term.c = (TCursor){{ .mode = ATTR_NULL, .fg = defaultfg, .bg = defaultbg }, .x = 0, .y = 0, .state = CURSOR_DEFAULT}; memset(term.tabs, 0, term.col * sizeof(*term.tabs)); for(i = tabspaces; i < term.col; i += tabspaces) term.tabs[i] = 1; term.top = 0; term.bot = term.row - 1; term.mode = MODE_WRAP; tclearregion(0, 0, term.col-1, term.row-1); tmoveto(0, 0); tcursor(CURSOR_SAVE); } void tnew(int col, int row) { term = (Term){ .c = { .attr = { .fg = defaultfg, .bg = defaultbg } } }; tresize(col, row); term.numlock = 1; treset(); } void tswapscreen(void) { Line *tmp = term.line; term.line = term.alt; term.alt = tmp; term.mode ^= MODE_ALTSCREEN; tfulldirt(); } void tscrolldown(int orig, int n) { int i; Line temp; LIMIT(n, 0, term.bot-orig+1); tclearregion(0, term.bot-n+1, term.col-1, term.bot); for(i = term.bot; i >= orig+n; i--) { temp = term.line[i]; term.line[i] = term.line[i-n]; term.line[i-n] = temp; term.dirty[i] = 1; term.dirty[i-n] = 1; } selscroll(orig, n); } void tscrollup(int orig, int n) { int i; Line temp; LIMIT(n, 0, term.bot-orig+1); tclearregion(0, orig, term.col-1, orig+n-1); for(i = orig; i <= term.bot-n; i++) { temp = term.line[i]; term.line[i] = term.line[i+n]; term.line[i+n] = temp; term.dirty[i] = 1; term.dirty[i+n] = 1; } selscroll(orig, -n); } void selscroll(int orig, int n) { if(sel.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(NULL); 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; } } selsort(); } } 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 = *p; } /* for absolute user moves, when decom is set */ void tmoveato(int x, int y) { tmoveto(x, y + ((term.c.state & CURSOR_ORIGIN) ? term.top: 0)); } void tmoveto(int x, int y) { int miny, maxy; if(term.c.state & CURSOR_ORIGIN) { miny = term.top; maxy = term.bot; } else { miny = 0; maxy = term.row - 1; } LIMIT(x, 0, term.col-1); LIMIT(y, miny, maxy); term.c.state &= ~CURSOR_WRAPNEXT; term.c.x = x; term.c.y = y; } void tsetchar(char *c, Glyph *attr, int x, int y) { static char *vt100_0[62] = { /* 0x41 - 0x7e */ "↑", "↓", "→", "←", "█", "▚", "☃", /* A - G */ 0, 0, 0, 0, 0, 0, 0, 0, /* H - O */ 0, 0, 0, 0, 0, 0, 0, 0, /* P - W */ 0, 0, 0, 0, 0, 0, 0, " ", /* X - _ */ "◆", "▒", "␉", "␌", "␍", "␊", "°", "±", /* ` - g */ "␤", "␋", "┘", "┐", "┌", "└", "┼", "⎺", /* h - o */ "⎻", "─", "⎼", "⎽", "├", "┤", "┴", "┬", /* p - w */ "│", "≤", "≥", "π", "≠", "£", "·", /* x - ~ */ }; /* * The table is proudly stolen from rxvt. */ if(attr->mode & ATTR_GFX) { if(c[0] >= 0x41 && c[0] <= 0x7e && vt100_0[c[0] - 0x41]) { c = vt100_0[c[0] - 0x41]; } } if(term.line[y][x].mode & ATTR_WIDE) { if(x+1 < term.col) { term.line[y][x+1].c[0] = ' '; term.line[y][x+1].mode &= ~ATTR_WDUMMY; } } else if(term.line[y][x].mode & ATTR_WDUMMY) { term.line[y][x-1].c[0] = ' '; term.line[y][x-1].mode &= ~ATTR_WIDE; } term.dirty[y] = 1; term.line[y][x] = *attr; memcpy(term.line[y][x].c, c, UTF_SIZ); } void tclearregion(int x1, int y1, int x2, int y2) { int x, y, temp; if(x1 > x2) temp = x1, x1 = x2, x2 = temp; if(y1 > y2) temp = y1, y1 = y2, y2 = temp; LIMIT(x1, 0, term.col-1); LIMIT(x2, 0, term.col-1); LIMIT(y1, 0, term.row-1); LIMIT(y2, 0, term.row-1); for(y = y1; y <= y2; y++) { term.dirty[y] = 1; for(x = x1; x <= x2; x++) { if(selected(x, y)) selclear(NULL); term.line[y][x] = term.c.attr; memcpy(term.line[y][x].c, " ", 2); } } } void tdeletechar(int n) { int src = term.c.x + n; int dst = term.c.x; int size = term.col - src; term.dirty[term.c.y] = 1; if(src >= term.col) { tclearregion(term.c.x, term.c.y, term.col-1, term.c.y); return; } memmove(&term.line[term.c.y][dst], &term.line[term.c.y][src], size * sizeof(Glyph)); tclearregion(term.col-n, term.c.y, term.col-1, term.c.y); } void tinsertblank(int n) { int src = term.c.x; int dst = src + n; int size = term.col - dst; term.dirty[term.c.y] = 1; if(dst >= term.col) { tclearregion(term.c.x, term.c.y, term.col-1, term.c.y); return; } memmove(&term.line[term.c.y][dst], &term.line[term.c.y][src], size * sizeof(Glyph)); tclearregion(src, term.c.y, dst - 1, term.c.y); } void tinsertblankline(int n) { if(term.c.y < term.top || term.c.y > term.bot) return; tscrolldown(term.c.y, n); } void tdeleteline(int n) { if(term.c.y < term.top || term.c.y > term.bot) return; tscrollup(term.c.y, n); } long tdefcolor(int *attr, int *npar, int l) { long idx = -1; uint r, g, b; switch (attr[*npar + 1]) { case 2: /* direct colour 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 (%d,%d,%d)\n", r, g, b); else idx = TRUECOLOR(r, g, b); break; case 5: /* indexed colour */ 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 colour in CMY space */ case 4: /* direct colour in CMYK space */ default: fprintf(stderr, "erresc(38): gfx attr %d unknown\n", attr[*npar]); } return idx; } void tsetattr(int *attr, int l) { int i; long idx; for(i = 0; i < l; i++) { switch(attr[i]) { case 0: term.c.attr.mode &= ~(ATTR_REVERSE | ATTR_UNDERLINE \ | ATTR_BOLD | ATTR_ITALIC \ | ATTR_BLINK); term.c.attr.fg = defaultfg; term.c.attr.bg = defaultbg; break; case 1: term.c.attr.mode |= ATTR_BOLD; break; case 3: term.c.attr.mode |= ATTR_ITALIC; break; case 4: term.c.attr.mode |= ATTR_UNDERLINE; break; case 5: /* slow blink */ case 6: /* rapid blink */ term.c.attr.mode |= ATTR_BLINK; break; case 7: term.c.attr.mode |= ATTR_REVERSE; break; case 21: case 22: term.c.attr.mode &= ~ATTR_BOLD; break; case 23: term.c.attr.mode &= ~ATTR_ITALIC; break; case 24: term.c.attr.mode &= ~ATTR_UNDERLINE; break; case 25: case 26: term.c.attr.mode &= ~ATTR_BLINK; break; case 27: term.c.attr.mode &= ~ATTR_REVERSE; break; case 38: if ((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; } #define MODBIT(x, set, bit) ((set) ? ((x) |= (bit)) : ((x) &= ~(bit))) void tsetmode(bool priv, bool set, int *args, int narg) { int *lim, mode; bool alt; for(lim = args + narg; args < lim; ++args) { if(priv) { switch(*args) { break; case 1: /* DECCKM -- Cursor key */ MODBIT(term.mode, set, MODE_APPCURSOR); break; case 5: /* DECSCNM -- Reverse video */ mode = term.mode; MODBIT(term.mode, set, MODE_REVERSE); if(mode != term.mode) redraw(REDRAW_TIMEOUT); break; case 6: /* DECOM -- Origin */ MODBIT(term.c.state, set, CURSOR_ORIGIN); tmoveato(0, 0); break; case 7: /* DECAWM -- Auto wrap */ MODBIT(term.mode, set, MODE_WRAP); break; case 0: /* Error (IGNORED) */ case 2: /* DECANM -- ANSI/VT52 (IGNORED) */ case 3: /* DECCOLM -- Column (IGNORED) */ case 4: /* DECSCLM -- Scroll (IGNORED) */ case 8: /* DECARM -- Auto repeat (IGNORED) */ case 18: /* DECPFF -- Printer feed (IGNORED) */ case 19: /* DECPEX -- Printer extent (IGNORED) */ case 42: /* DECNRCM -- National characters (IGNORED) */ case 12: /* att610 -- Start blinking cursor (IGNORED) */ break; case 25: /* DECTCEM -- Text Cursor Enable Mode */ MODBIT(term.mode, !set, MODE_HIDE); break; case 9: /* X10 mouse compatibility mode */ xsetpointermotion(0); MODBIT(term.mode, 0, MODE_MOUSE); MODBIT(term.mode, set, MODE_MOUSEX10); break; case 1000: /* 1000: report button press */ xsetpointermotion(0); MODBIT(term.mode, 0, MODE_MOUSE); MODBIT(term.mode, set, MODE_MOUSEBTN); break; case 1002: /* 1002: report motion on button press */ xsetpointermotion(0); MODBIT(term.mode, 0, MODE_MOUSE); MODBIT(term.mode, set, MODE_MOUSEMOTION); break; case 1003: /* 1003: enable all mouse motions */ xsetpointermotion(set); MODBIT(term.mode, 0, MODE_MOUSE); MODBIT(term.mode, set, MODE_MOUSEMANY); break; case 1004: /* 1004: send focus events to tty */ MODBIT(term.mode, set, MODE_FOCUS); break; case 1006: /* 1006: extended reporting mode */ MODBIT(term.mode, set, MODE_MOUSESGR); break; case 1034: MODBIT(term.mode, set, MODE_8BIT); break; case 1049: /* = 1047 and 1048 */ case 47: 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; /* FALLTRU */ case 1048: tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD); break; case 2004: /* 2004: bracketed paste mode */ MODBIT(term.mode, 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: /* KAM -- keyboard action */ MODBIT(term.mode, set, MODE_KBDLOCK); break; case 4: /* IRM -- Insertion-replacement */ MODBIT(term.mode, set, MODE_INSERT); break; case 12: /* SRM -- Send/Receive */ MODBIT(term.mode, !set, MODE_ECHO); break; case 20: /* LNM -- Linefeed/new line */ MODBIT(term.mode, set, MODE_CRLF); break; default: fprintf(stderr, "erresc: unknown set/reset mode %d\n", *args); break; } } } } void csihandle(void) { switch(csiescseq.mode) { 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 'c': /* DA -- Device Attributes */ if(csiescseq.arg[0] == 0) ttywrite(VT102ID, sizeof(VT102ID) - 1); 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); while(csiescseq.arg[0]--) tputtab(1); break; case 'J': /* ED -- Clear screen */ selclear(NULL); 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); while(csiescseq.arg[0]--) tputtab(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 'r': /* DECSTBM -- Set Scrolling Region */ if(csiescseq.priv) { goto unknown; } else { DEFAULT(csiescseq.arg[0], 1); DEFAULT(csiescseq.arg[1], term.row); tsetscroll(csiescseq.arg[0]-1, csiescseq.arg[1]-1); tmoveato(0, 0); } break; case 's': /* DECSC -- Save cursor position (ANSI.SYS) */ tcursor(CURSOR_SAVE); break; case 'u': /* DECRC -- Restore cursor position (ANSI.SYS) */ tcursor(CURSOR_LOAD); break; } } void csidump(void) { int i; uint c; printf("ESC["); for(i = 0; i < csiescseq.len; i++) { c = csiescseq.buf[i] & 0xff; if(isprint(c)) { putchar(c); } else if(c == '\n') { printf("(\\n)"); } else if(c == '\r') { printf("(\\r)"); } else if(c == 0x1b) { printf("(\\e)"); } else { printf("(%02x)", c); } } putchar('\n'); } void csireset(void) { memset(&csiescseq, 0, sizeof(csiescseq)); } void strhandle(void) { char *p = NULL; int i, j, narg; strparse(); narg = strescseq.narg; switch(strescseq.type) { case ']': /* OSC -- Operating System Command */ switch(i = atoi(strescseq.args[0])) { case 0: case 1: case 2: if(narg > 1) xsettitle(strescseq.args[1]); break; case 4: /* color set */ if(narg < 3) break; p = strescseq.args[2]; /* fall through */ 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(0); } break; default: fprintf(stderr, "erresc: unknown str "); strdump(); break; } break; case 'k': /* old title set compatibility */ xsettitle(strescseq.args[0]); break; case 'P': /* DSC -- Device Control String */ case '_': /* APC -- Application Program Command */ case '^': /* PM -- Privacy Message */ default: fprintf(stderr, "erresc: unknown str "); strdump(); /* die(""); */ break; } } void strparse(void) { char *p = strescseq.buf; strescseq.narg = 0; strescseq.buf[strescseq.len] = '\0'; while(p && strescseq.narg < STR_ARG_SIZ) strescseq.args[strescseq.narg++] = strsep(&p, ";"); } void strdump(void) { int i; uint c; printf("ESC%c", strescseq.type); for(i = 0; i < strescseq.len; i++) { c = strescseq.buf[i] & 0xff; if(c == '\0') { return; } else if(isprint(c)) { putchar(c); } else if(c == '\n') { printf("(\\n)"); } else if(c == '\r') { printf("(\\r)"); } else if(c == 0x1b) { printf("(\\e)"); } else { printf("(%02x)", c); } } printf("ESC\\\n"); } void strreset(void) { memset(&strescseq, 0, sizeof(strescseq)); } void tputtab(bool forward) { uint x = term.c.x; if(forward) { if(x == term.col) return; for(++x; x < term.col && !term.tabs[x]; ++x) /* nothing */ ; } else { if(x == 0) return; for(--x; x > 0 && !term.tabs[x]; --x) /* nothing */ ; } tmoveto(x, term.c.y); } void techo(char *buf, int len) { for(; len > 0; buf++, len--) { char c = *buf; if(c == '\033') { /* escape */ tputc("^", 1); tputc("[", 1); } else if(c < '\x20') { /* control code */ if(c != '\n' && c != '\r' && c != '\t') { c |= '\x40'; tputc("^", 1); } tputc(&c, 1); } else { break; } } if(len) tputc(buf, len); } void tputc(char *c, int len) { uchar ascii = *c; bool control = ascii < '\x20' || ascii == 0177; long u8char; int width; if(len == 1) { width = 1; } else { utf8decode(c, &u8char); width = wcwidth(u8char); } if(iofd != -1) { if(xwrite(iofd, c, len) < 0) { fprintf(stderr, "Error writing in %s:%s\n", opt_io, strerror(errno)); close(iofd); iofd = -1; } } /* * STR sequences must be checked before anything else * because it can use some control codes as part of the sequence. */ if(term.esc & ESC_STR) { switch(ascii) { case '\033': term.esc = ESC_START | ESC_STR_END; break; case '\a': /* backwards compatibility to xterm */ term.esc = 0; strhandle(); break; default: if(strescseq.len + len < sizeof(strescseq.buf) - 1) { memmove(&strescseq.buf[strescseq.len], c, len); strescseq.len += len; } else { /* * Here is a bug in terminals. If the user never sends * some code to stop the str or esc command, then st * will stop responding. But this is better than * silently failing with unknown characters. At least * then users will report back. * * In the case users ever get fixed, here is the code: */ /* * term.esc = 0; * strhandle(); */ } } return; } /* * Actions of control codes must be performed as soon they arrive * because they can be embedded inside a control sequence, and * they must not cause conflicts with sequences. */ if(control) { switch(ascii) { case '\t': /* HT */ tputtab(1); return; case '\b': /* BS */ tmoveto(term.c.x-1, term.c.y); return; case '\r': /* CR */ tmoveto(0, term.c.y); return; case '\f': /* LF */ case '\v': /* VT */ case '\n': /* LF */ /* go to first col if the mode is set */ tnewline(IS_SET(MODE_CRLF)); return; case '\a': /* BEL */ if(!(xw.state & WIN_FOCUSED)) xseturgency(1); if (bellvolume) XBell(xw.dpy, bellvolume); return; case '\033': /* ESC */ csireset(); term.esc = ESC_START; return; case '\016': /* SO */ case '\017': /* SI */ /* * Different charsets are hard to handle. Applications * should use the right alt charset escapes for the * only reason they still exist: line drawing. The * rest is incompatible history st should not support. */ return; case '\032': /* SUB */ case '\030': /* CAN */ csireset(); return; case '\005': /* ENQ (IGNORED) */ case '\000': /* NUL (IGNORED) */ case '\021': /* XON (IGNORED) */ case '\023': /* XOFF (IGNORED) */ case 0177: /* DEL (IGNORED) */ return; } } else if(term.esc & ESC_START) { if(term.esc & ESC_CSI) { csiescseq.buf[csiescseq.len++] = ascii; if(BETWEEN(ascii, 0x40, 0x7E) || csiescseq.len >= \ sizeof(csiescseq.buf)-1) { term.esc = 0; csiparse(); csihandle(); } } else if(term.esc & ESC_STR_END) { term.esc = 0; if(ascii == '\\') strhandle(); } else if(term.esc & ESC_ALTCHARSET) { switch(ascii) { case '0': /* Line drawing set */ term.c.attr.mode |= ATTR_GFX; break; case 'B': /* USASCII */ term.c.attr.mode &= ~ATTR_GFX; break; case 'A': /* UK (IGNORED) */ case '<': /* multinational charset (IGNORED) */ case '5': /* Finnish (IGNORED) */ case 'C': /* Finnish (IGNORED) */ case 'K': /* German (IGNORED) */ break; default: fprintf(stderr, "esc unhandled charset: ESC ( %c\n", ascii); } term.esc = 0; } else if(term.esc & ESC_TEST) { if(ascii == '8') { /* DEC screen alignment test. */ char E[UTF_SIZ] = "E"; int x, y; for(x = 0; x < term.col; ++x) { for(y = 0; y < term.row; ++y) tsetchar(E, &term.c.attr, x, y); } } term.esc = 0; } else { switch(ascii) { case '[': term.esc |= ESC_CSI; break; case '#': term.esc |= ESC_TEST; break; case 'P': /* DCS -- Device Control String */ case '_': /* APC -- Application Program Command */ case '^': /* PM -- Privacy Message */ case ']': /* OSC -- Operating System Command */ case 'k': /* old title set compatibility */ strreset(); strescseq.type = ascii; term.esc |= ESC_STR; break; case '(': /* set primary charset G0 */ term.esc |= ESC_ALTCHARSET; break; case ')': /* set secondary charset G1 (IGNORED) */ case '*': /* set tertiary charset G2 (IGNORED) */ case '+': /* set quaternary charset G3 (IGNORED) */ term.esc = 0; break; case 'D': /* IND -- Linefeed */ if(term.c.y == term.bot) { tscrollup(term.top, 1); } else { tmoveto(term.c.x, term.c.y+1); } term.esc = 0; break; case 'E': /* NEL -- Next line */ tnewline(1); /* always go to first col */ term.esc = 0; break; case 'H': /* HTS -- Horizontal tab stop */ term.tabs[term.c.x] = 1; term.esc = 0; break; case 'M': /* RI -- Reverse index */ if(term.c.y == term.top) { tscrolldown(term.top, 1); } else { tmoveto(term.c.x, term.c.y-1); } term.esc = 0; break; case 'Z': /* DECID -- Identify Terminal */ ttywrite(VT102ID, sizeof(VT102ID) - 1); term.esc = 0; break; case 'c': /* RIS -- Reset to inital state */ treset(); term.esc = 0; xresettitle(); xloadcols(); break; case '=': /* DECPAM -- Application keypad */ term.mode |= MODE_APPKEYPAD; term.esc = 0; break; case '>': /* DECPNM -- Normal keypad */ term.mode &= ~MODE_APPKEYPAD; term.esc = 0; break; case '7': /* DECSC -- Save Cursor */ tcursor(CURSOR_SAVE); term.esc = 0; break; case '8': /* DECRC -- Restore Cursor */ tcursor(CURSOR_LOAD); term.esc = 0; break; case '\\': /* ST -- Stop */ term.esc = 0; break; default: fprintf(stderr, "erresc: unknown sequence ESC 0x%02X '%c'\n", (uchar) ascii, isprint(ascii)? ascii:'.'); term.esc = 0; } } /* * All characters which form part of a sequence are not * printed */ return; } /* * Display control codes only if we are in graphic mode */ if(control && !(term.c.attr.mode & ATTR_GFX)) return; if(sel.ob.x != -1 && BETWEEN(term.c.y, sel.ob.y, sel.oe.y)) selclear(NULL); if(IS_SET(MODE_WRAP) && (term.c.state & CURSOR_WRAPNEXT)) { term.line[term.c.y][term.c.x].mode |= ATTR_WRAP; tnewline(1); } if(IS_SET(MODE_INSERT) && term.c.x+1 < term.col) { memmove(&term.line[term.c.y][term.c.x+1], &term.line[term.c.y][term.c.x], (term.col - term.c.x - 1) * sizeof(Glyph)); } if(term.c.x+width > term.col) tnewline(1); tsetchar(c, &term.c.attr, term.c.x, term.c.y); if(width == 2) { term.line[term.c.y][term.c.x].mode |= ATTR_WIDE; if(term.c.x+1 < term.col) { term.line[term.c.y][term.c.x+1].c[0] = '\0'; term.line[term.c.y][term.c.x+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 tresize(int col, int row) { int i; int minrow = MIN(row, term.row); int mincol = MIN(col, term.col); int slide = term.c.y - row + 1; bool *bp; Line *orig; if(col < 1 || row < 1) return 0; /* free unneeded rows */ i = 0; if(slide > 0) { /* * slide screen to keep cursor where we expect it - * tscrollup would work here, but we can optimize to * memmove because we're freeing the earlier lines */ for(/* i = 0 */; i < slide; i++) { free(term.line[i]); free(term.alt[i]); } memmove(term.line, term.line + slide, row * sizeof(Line)); memmove(term.alt, term.alt + slide, row * sizeof(Line)); } for(i += row; i < term.row; i++) { free(term.line[i]); free(term.alt[i]); } /* resize to new height */ term.line = xrealloc(term.line, row * sizeof(Line)); term.alt = xrealloc(term.alt, row * sizeof(Line)); term.dirty = xrealloc(term.dirty, row * sizeof(*term.dirty)); term.tabs = xrealloc(term.tabs, col * sizeof(*term.tabs)); /* resize each row to new width, zero-pad if needed */ for(i = 0; i < minrow; i++) { term.dirty[i] = 1; term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph)); term.alt[i] = xrealloc(term.alt[i], col * sizeof(Glyph)); } /* allocate any new rows */ for(/* i == minrow */; i < row; i++) { term.dirty[i] = 1; 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 */ orig = term.line; do { 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(); } while(orig != term.line); return (slide > 0); } void xresize(int col, int row) { xw.tw = MAX(1, col * xw.cw); xw.th = MAX(1, row * xw.ch); XFreePixmap(xw.dpy, xw.buf); xw.buf = XCreatePixmap(xw.dpy, xw.win, xw.w, xw.h, DefaultDepth(xw.dpy, xw.scr)); XftDrawChange(xw.draw, xw.buf); xclear(0, 0, xw.w, xw.h); } static inline ushort sixd_to_16bit(int x) { return x == 0 ? 0 : 0x3737 + 0x2828 * x; } void xloadcols(void) { int i, r, g, b; XRenderColor color = { .alpha = 0xffff }; static bool loaded; Colour *cp; if(loaded) { for (cp = dc.col; cp < dc.col + LEN(dc.col); ++cp) XftColorFree(xw.dpy, xw.vis, xw.cmap, cp); } /* load colors [0-15] colors and [256-LEN(colorname)[ (config.h) */ for(i = 0; i < LEN(colorname); i++) { if(!colorname[i]) continue; if(!XftColorAllocName(xw.dpy, xw.vis, xw.cmap, colorname[i], &dc.col[i])) { die("Could not allocate color '%s'\n", colorname[i]); } } /* load colors [16-255] ; same colors as xterm */ for(i = 16, r = 0; r < 6; r++) { for(g = 0; g < 6; g++) { for(b = 0; b < 6; b++) { color.red = sixd_to_16bit(r); color.green = sixd_to_16bit(g); color.blue = sixd_to_16bit(b); if(!XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &color, &dc.col[i])) { die("Could not allocate color %d\n", i); } i++; } } } for(r = 0; r < 24; r++, i++) { color.red = color.green = color.blue = 0x0808 + 0x0a0a * r; if(!XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &color, &dc.col[i])) { die("Could not allocate color %d\n", i); } } loaded = true; } int xsetcolorname(int x, const char *name) { XRenderColor color = { .alpha = 0xffff }; Colour colour; if (x < 0 || x > LEN(colorname)) return -1; if(!name) { if(16 <= x && x < 16 + 216) { int r = (x - 16) / 36, g = ((x - 16) % 36) / 6, b = (x - 16) % 6; color.red = sixd_to_16bit(r); color.green = sixd_to_16bit(g); color.blue = sixd_to_16bit(b); if(!XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &color, &colour)) return 0; /* something went wrong */ dc.col[x] = colour; return 1; } else if (16 + 216 <= x && x < 256) { color.red = color.green = color.blue = 0x0808 + 0x0a0a * (x - (16 + 216)); if(!XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &color, &colour)) return 0; /* something went wrong */ dc.col[x] = colour; return 1; } else { name = colorname[x]; } } if(!XftColorAllocName(xw.dpy, xw.vis, xw.cmap, name, &colour)) return 0; dc.col[x] = colour; return 1; } void xtermclear(int col1, int row1, int col2, int row2) { XftDrawRect(xw.draw, &dc.col[IS_SET(MODE_REVERSE) ? defaultfg : defaultbg], borderpx + col1 * xw.cw, borderpx + row1 * xw.ch, (col2-col1+1) * xw.cw, (row2-row1+1) * xw.ch); } /* * Absolute coordinates. */ void xclear(int x1, int y1, int x2, int y2) { XftDrawRect(xw.draw, &dc.col[IS_SET(MODE_REVERSE)? defaultfg : defaultbg], x1, y1, x2-x1, y2-y1); } void xhints(void) { XClassHint class = {opt_class ? opt_class : termname, termname}; XWMHints wm = {.flags = InputHint, .input = 1}; XSizeHints *sizeh = NULL; sizeh = XAllocSizeHints(); if(xw.isfixed == False) { sizeh->flags = PSize | PResizeInc | PBaseSize; sizeh->height = xw.h; sizeh->width = xw.w; sizeh->height_inc = xw.ch; sizeh->width_inc = xw.cw; sizeh->base_height = 2 * borderpx; sizeh->base_width = 2 * borderpx; } else { sizeh->flags = PMaxSize | PMinSize; sizeh->min_width = sizeh->max_width = xw.fw; sizeh->min_height = sizeh->max_height = xw.fh; } XSetWMProperties(xw.dpy, xw.win, NULL, NULL, NULL, 0, sizeh, &wm, &class); XFree(sizeh); } int xloadfont(Font *f, FcPattern *pattern) { FcPattern *match; FcResult result; match = FcFontMatch(NULL, pattern, &result); if(!match) return 1; if(!(f->match = XftFontOpenPattern(xw.dpy, match))) { FcPatternDestroy(match); return 1; } f->set = NULL; f->pattern = FcPatternDuplicate(pattern); f->ascent = f->match->ascent; f->descent = f->match->descent; f->lbearing = 0; f->rbearing = f->match->max_advance_width; f->height = f->ascent + f->descent; f->width = f->lbearing + f->rbearing; return 0; } void xloadfonts(char *fontstr, int fontsize) { FcPattern *pattern; FcResult result; double fontval; if(fontstr[0] == '-') { pattern = XftXlfdParse(fontstr, False, False); } else { pattern = FcNameParse((FcChar8 *)fontstr); } if(!pattern) die("st: can't open font %s\n", fontstr); if(fontsize > 0) { FcPatternDel(pattern, FC_PIXEL_SIZE); FcPatternAddDouble(pattern, FC_PIXEL_SIZE, (double)fontsize); usedfontsize = fontsize; } else { result = FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &fontval); if(result == FcResultMatch) { usedfontsize = (int)fontval; } 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; } } FcConfigSubstitute(0, pattern, FcMatchPattern); FcDefaultSubstitute(pattern); if(xloadfont(&dc.font, pattern)) die("st: can't open font %s\n", fontstr); /* Setting character width and height. */ xw.cw = CEIL(dc.font.width * cwscale); xw.ch = CEIL(dc.font.height * chscale); FcPatternDel(pattern, FC_SLANT); FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC); if(xloadfont(&dc.ifont, pattern)) die("st: can't open font %s\n", fontstr); FcPatternDel(pattern, FC_WEIGHT); FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD); if(xloadfont(&dc.ibfont, pattern)) die("st: can't open font %s\n", fontstr); FcPatternDel(pattern, FC_SLANT); FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ROMAN); if(xloadfont(&dc.bfont, pattern)) die("st: can't open font %s\n", fontstr); FcPatternDestroy(pattern); } int xloadfontset(Font *f) { FcResult result; if(!(f->set = FcFontSort(0, f->pattern, FcTrue, 0, &result))) return 1; return 0; } void xunloadfont(Font *f) { XftFontClose(xw.dpy, f->match); FcPatternDestroy(f->pattern); if(f->set) FcFontSetDestroy(f->set); } void xunloadfonts(void) { int i; /* Free the loaded fonts in the font cache. */ for(i = 0; i < frclen; i++) { XftFontClose(xw.dpy, frc[i].font); } frclen = 0; xunloadfont(&dc.font); xunloadfont(&dc.bfont); xunloadfont(&dc.ifont); xunloadfont(&dc.ibfont); } void xzoom(const Arg *arg) { xunloadfonts(); xloadfonts(usedfont, usedfontsize + arg->i); cresize(0, 0); redraw(0); } void xinit(void) { XGCValues gcvalues; Cursor cursor; Window parent; int sw, sh; 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 */ if(xw.isfixed) { sw = DisplayWidth(xw.dpy, xw.scr); sh = DisplayHeight(xw.dpy, xw.scr); if(xw.fx < 0) xw.fx = sw + xw.fx - xw.fw - 1; if(xw.fy < 0) xw.fy = sh + xw.fy - xw.fh - 1; xw.h = xw.fh; xw.w = xw.fw; } else { /* window - default size */ xw.h = 2 * borderpx + term.row * xw.ch; xw.w = 2 * borderpx + term.col * xw.cw; xw.fx = 0; xw.fy = 0; } /* 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; parent = opt_embed ? strtol(opt_embed, NULL, 0) : \ XRootWindow(xw.dpy, xw.scr); xw.win = XCreateWindow(xw.dpy, parent, xw.fx, xw.fy, xw.w, xw.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, xw.w, xw.h, DefaultDepth(xw.dpy, xw.scr)); XSetForeground(xw.dpy, dc.gc, dc.col[defaultbg].pixel); XFillRectangle(xw.dpy, xw.buf, dc.gc, 0, 0, xw.w, xw.h); /* 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, XC_xterm); XDefineCursor(xw.dpy, xw.win, cursor); XRecolorCursor(xw.dpy, cursor, &(XColor){.red = 0xffff, .green = 0xffff, .blue = 0xffff}, &(XColor){.red = 0x0000, .green = 0x0000, .blue = 0x0000}); xw.xembed = XInternAtom(xw.dpy, "_XEMBED", False); xw.wmdeletewin = XInternAtom(xw.dpy, "WM_DELETE_WINDOW", False); XSetWMProtocols(xw.dpy, xw.win, &xw.wmdeletewin, 1); xresettitle(); XMapWindow(xw.dpy, xw.win); xhints(); XSync(xw.dpy, 0); } void xdraws(char *s, Glyph base, int x, int y, int charlen, int bytelen) { int winx = borderpx + x * xw.cw, winy = borderpx + y * xw.ch, width = charlen * xw.cw, xp, i; int frcflags; int u8fl, u8fblen, u8cblen, doesexist; char *u8c, *u8fs; long u8char; Font *font = &dc.font; FcResult fcres; FcPattern *fcpattern, *fontpattern; FcFontSet *fcsets[] = { NULL }; FcCharSet *fccharset; Colour *fg, *bg, *temp, revfg, revbg, truefg, truebg; XRenderColor colfg, colbg; Rectangle r; int oneatatime; frcflags = FRC_NORMAL; if(base.mode & ATTR_ITALIC) { if(base.fg == defaultfg) base.fg = defaultitalic; font = &dc.ifont; frcflags = FRC_ITALIC; } else if((base.mode & ATTR_ITALIC) && (base.mode & ATTR_BOLD)) { if(base.fg == defaultfg) base.fg = defaultitalic; font = &dc.ibfont; frcflags = FRC_ITALICBOLD; } else if(base.mode & ATTR_UNDERLINE) { if(base.fg == defaultfg) base.fg = defaultunderline; } if(IS_TRUECOL(base.fg)) { 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.green = TRUEGREEN(base.bg); colbg.red = TRUERED(base.bg); colbg.blue = TRUEBLUE(base.bg); XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &colbg, &truebg); bg = &truebg; } else { bg = &dc.col[base.bg]; } if(base.mode & ATTR_BOLD) { if(BETWEEN(base.fg, 0, 7)) { /* basic system colors */ fg = &dc.col[base.fg + 8]; } else if(BETWEEN(base.fg, 16, 195)) { /* 256 colors */ fg = &dc.col[base.fg + 36]; } else if(BETWEEN(base.fg, 232, 251)) { /* greyscale */ fg = &dc.col[base.fg + 4]; } /* * Those ranges will not be brightened: * 8 - 15 – bright system colors * 196 - 231 – highest 256 color cube * 252 - 255 – brightest colors in greyscale */ font = &dc.bfont; frcflags = FRC_BOLD; } 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_REVERSE) { temp = fg; fg = bg; bg = temp; } if(base.mode & ATTR_BLINK && term.mode & MODE_BLINK) fg = bg; /* Intelligent cleaning up of the borders. */ if(x == 0) { xclear(0, (y == 0)? 0 : winy, borderpx, winy + xw.ch + ((y >= term.row-1)? xw.h : 0)); } if(x + charlen >= term.col) { xclear(winx + width, (y == 0)? 0 : winy, xw.w, ((y >= term.row-1)? xw.h : (winy + xw.ch))); } if(y == 0) xclear(winx, 0, winx + width, borderpx); if(y == term.row-1) xclear(winx, winy + xw.ch, winx + width, xw.h); /* Clean up the region we want to draw to. */ XftDrawRect(xw.draw, bg, winx, winy, width, xw.ch); /* Set the clip region because Xft is sometimes dirty. */ r.x = 0; r.y = 0; r.height = xw.ch; r.width = width; XftDrawSetClipRectangles(xw.draw, winx, winy, &r, 1); for(xp = winx; bytelen > 0;) { /* * Search for the range in the to be printed string of glyphs * that are in the main font. Then print that range. If * some glyph is found that is not in the font, do the * fallback dance. */ u8fs = s; u8fblen = 0; u8fl = 0; oneatatime = font->width != xw.cw; for(;;) { u8c = s; u8cblen = utf8decode(s, &u8char); s += u8cblen; bytelen -= u8cblen; doesexist = XftCharExists(xw.dpy, font->match, u8char); if(oneatatime || !doesexist || bytelen <= 0) { if(oneatatime || bytelen <= 0) { if(doesexist) { u8fl++; u8fblen += u8cblen; } } if(u8fl > 0) { XftDrawStringUtf8(xw.draw, fg, font->match, xp, winy + font->ascent, (FcChar8 *)u8fs, u8fblen); xp += xw.cw * u8fl; } break; } u8fl++; u8fblen += u8cblen; } if(doesexist) { if (oneatatime) continue; break; } /* Search the font cache. */ for(i = 0; i < frclen; i++) { if(XftCharExists(xw.dpy, frc[i].font, u8char) && frc[i].flags == frcflags) { break; } } /* Nothing was found. */ if(i >= frclen) { if(!font->set) xloadfontset(font); 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. */ fcpattern = FcPatternDuplicate(font->pattern); fccharset = FcCharSetCreate(); FcCharSetAddChar(fccharset, u8char); FcPatternAddCharSet(fcpattern, FC_CHARSET, fccharset); FcPatternAddBool(fcpattern, FC_SCALABLE, FcTrue); FcConfigSubstitute(0, fcpattern, FcMatchPattern); FcDefaultSubstitute(fcpattern); fontpattern = FcFontSetMatch(0, fcsets, FcTrue, 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].font = XftFontOpenPattern(xw.dpy, fontpattern); frc[frclen].flags = frcflags; i = frclen; frclen++; FcPatternDestroy(fcpattern); FcCharSetDestroy(fccharset); } XftDrawStringUtf8(xw.draw, fg, frc[i].font, xp, winy + frc[i].font->ascent, (FcChar8 *)u8c, u8cblen); xp += xw.cw * wcwidth(u8char); } /* XftDrawStringUtf8(xw.draw, fg, font->set, winx, winy + font->ascent, (FcChar8 *)s, bytelen); */ if(base.mode & ATTR_UNDERLINE) { XftDrawRect(xw.draw, fg, winx, winy + font->ascent + 1, width, 1); } /* Reset clip to none. */ XftDrawSetClip(xw.draw, 0); } void xdrawcursor(void) { static int oldx = 0, oldy = 0; int sl, width, curx; Glyph g = {{' '}, ATTR_NULL, defaultbg, defaultcs}; LIMIT(oldx, 0, term.col-1); LIMIT(oldy, 0, term.row-1); curx = term.c.x; /* adjust position if in dummy */ if(term.line[oldy][oldx].mode & ATTR_WDUMMY) oldx--; if(term.line[term.c.y][curx].mode & ATTR_WDUMMY) curx--; memcpy(g.c, term.line[term.c.y][term.c.x].c, UTF_SIZ); /* remove the old cursor */ sl = utf8size(term.line[oldy][oldx].c); width = (term.line[oldy][oldx].mode & ATTR_WIDE)? 2 : 1; xdraws(term.line[oldy][oldx].c, term.line[oldy][oldx], oldx, oldy, width, sl); /* draw the new one */ if(!(IS_SET(MODE_HIDE))) { if(xw.state & WIN_FOCUSED) { if(IS_SET(MODE_REVERSE)) { g.mode |= ATTR_REVERSE; g.fg = defaultcs; g.bg = defaultfg; } sl = utf8size(g.c); width = (term.line[term.c.y][curx].mode & ATTR_WIDE)\ ? 2 : 1; xdraws(g.c, g, term.c.x, term.c.y, width, sl); } else { XftDrawRect(xw.draw, &dc.col[defaultcs], borderpx + curx * xw.cw, borderpx + term.c.y * xw.ch, xw.cw - 1, 1); XftDrawRect(xw.draw, &dc.col[defaultcs], borderpx + curx * xw.cw, borderpx + term.c.y * xw.ch, 1, xw.ch - 1); XftDrawRect(xw.draw, &dc.col[defaultcs], borderpx + (curx + 1) * xw.cw - 1, borderpx + term.c.y * xw.ch, 1, xw.ch - 1); XftDrawRect(xw.draw, &dc.col[defaultcs], borderpx + curx * xw.cw, borderpx + (term.c.y + 1) * xw.ch - 1, xw.cw, 1); } oldx = curx, oldy = term.c.y; } } void xsettitle(char *p) { XTextProperty prop; Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle, &prop); XSetWMName(xw.dpy, xw.win, &prop); XFree(prop.value); } void xresettitle(void) { xsettitle(opt_title ? opt_title : "st"); } void redraw(int timeout) { struct timespec tv = {0, timeout * 1000}; tfulldirt(); draw(); if(timeout > 0) { nanosleep(&tv, NULL); XSync(xw.dpy, False); /* necessary for a good tput flash */ } } void draw(void) { drawregion(0, 0, term.col, term.row); XCopyArea(xw.dpy, xw.buf, xw.win, dc.gc, 0, 0, xw.w, xw.h, 0, 0); XSetForeground(xw.dpy, dc.gc, dc.col[IS_SET(MODE_REVERSE)? defaultfg : defaultbg].pixel); } void drawregion(int x1, int y1, int x2, int y2) { int ic, ib, x, y, ox, sl; Glyph base, new; char buf[DRAW_BUF_SIZ]; bool ena_sel = sel.ob.x != -1; long u8char; if(sel.alt ^ IS_SET(MODE_ALTSCREEN)) ena_sel = 0; if(!(xw.state & WIN_VISIBLE)) return; for(y = y1; y < y2; y++) { if(!term.dirty[y]) continue; xtermclear(0, y, term.col, y); term.dirty[y] = 0; base = term.line[y][0]; ic = ib = ox = 0; for(x = x1; x < x2; x++) { new = term.line[y][x]; if(new.mode == ATTR_WDUMMY) continue; if(ena_sel && selected(x, y)) new.mode ^= ATTR_REVERSE; if(ib > 0 && (ATTRCMP(base, new) || ib >= DRAW_BUF_SIZ-UTF_SIZ)) { xdraws(buf, base, ox, y, ic, ib); ic = ib = 0; } if(ib == 0) { ox = x; base = new; } sl = utf8decode(new.c, &u8char); memcpy(buf+ib, new.c, sl); ib += sl; ic += (new.mode & ATTR_WIDE)? 2 : 1; } if(ib > 0) xdraws(buf, base, ox, y, ic, ib); } xdrawcursor(); } void expose(XEvent *ev) { XExposeEvent *e = &ev->xexpose; if(xw.state & WIN_REDRAW) { if(!e->count) xw.state &= ~WIN_REDRAW; } redraw(0); } void visibility(XEvent *ev) { XVisibilityEvent *e = &ev->xvisibility; if(e->state == VisibilityFullyObscured) { xw.state &= ~WIN_VISIBLE; } else if(!(xw.state & WIN_VISIBLE)) { /* need a full redraw for next Expose, not just a buf copy */ xw.state |= WIN_VISIBLE | WIN_REDRAW; } } void unmap(XEvent *ev) { xw.state &= ~WIN_VISIBLE; } void xsetpointermotion(int set) { MODBIT(xw.attrs.event_mask, set, PointerMotionMask); XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, &xw.attrs); } void xseturgency(int add) { XWMHints *h = XGetWMHints(xw.dpy, xw.win); h->flags = add ? (h->flags | XUrgencyHint) : (h->flags & ~XUrgencyHint); XSetWMHints(xw.dpy, xw.win, h); XFree(h); } void focus(XEvent *ev) { XFocusChangeEvent *e = &ev->xfocus; if(e->mode == NotifyGrab) return; if(ev->type == FocusIn) { XSetICFocus(xw.xic); xw.state |= WIN_FOCUSED; xseturgency(0); if(IS_SET(MODE_FOCUS)) ttywrite("\033[I", 3); } else { XUnsetICFocus(xw.xic); xw.state &= ~WIN_FOCUSED; if(IS_SET(MODE_FOCUS)) ttywrite("\033[O", 3); } } static inline bool match(uint mask, uint state) { state &= ~ignoremod; if(mask == XK_NO_MOD && state) return false; if(mask != XK_ANY_MOD && mask != XK_NO_MOD && !state) return false; if(mask == XK_ANY_MOD) return true; return state == mask; } void numlock(const Arg *dummy) { term.numlock ^= 1; } 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(kp->appkey > 0) { if(!IS_SET(MODE_APPKEYPAD)) continue; if(term.numlock && kp->appkey == 2) continue; } else if(kp->appkey < 0 && IS_SET(MODE_APPKEYPAD)) { continue; } if((kp->appcursor < 0 && IS_SET(MODE_APPCURSOR)) || (kp->appcursor > 0 && !IS_SET(MODE_APPCURSOR))) { continue; } if((kp->crlf < 0 && IS_SET(MODE_CRLF)) || (kp->crlf > 0 && !IS_SET(MODE_CRLF))) { continue; } return kp->s; } return NULL; } void kpress(XEvent *ev) { XKeyEvent *e = &ev->xkey; KeySym ksym; char xstr[31], buf[32], *customkey, *cp = buf; int len, ret; long c; Status status; Shortcut *bp; if(IS_SET(MODE_KBDLOCK)) return; len = XmbLookupString(xw.xic, e, xstr, sizeof(xstr), &ksym, &status); e->state &= ~Mod2Mask; /* 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))) { len = strlen(customkey); memcpy(buf, customkey, len); /* 3. hardcoded (overrides X lookup) */ } else { if(len == 0) return; if(len == 1 && e->state & Mod1Mask) { if(IS_SET(MODE_8BIT)) { if(*xstr < 0177) { c = *xstr | 0x80; ret = utf8encode(&c, cp); cp += ret; len = 0; } } else { *cp++ = '\033'; } } memcpy(cp, xstr, len); len = cp - buf + len; } ttywrite(buf, len); if(IS_SET(MODE_ECHO)) techo(buf, len); } 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) { xw.state |= WIN_FOCUSED; xseturgency(0); } else if(e->xclient.data.l[1] == XEMBED_FOCUS_OUT) { xw.state &= ~WIN_FOCUSED; } } else if(e->xclient.data.l[0] == xw.wmdeletewin) { /* Send SIGHUP to shell */ kill(pid, SIGHUP); exit(EXIT_SUCCESS); } } void cresize(int width, int height) { int col, row; if(width != 0) xw.w = width; if(height != 0) xw.h = height; col = (xw.w - 2 * borderpx) / xw.cw; row = (xw.h - 2 * borderpx) / xw.ch; tresize(col, row); xresize(col, row); ttyresize(); } void resize(XEvent *e) { if(e->xconfigure.width == xw.w && e->xconfigure.height == xw.h) return; cresize(e->xconfigure.width, e->xconfigure.height); } void run(void) { XEvent ev; int w = xw.w, h = xw.h; fd_set rfd; int xfd = XConnectionNumber(xw.dpy), xev, blinkset = 0, dodraw = 0; struct timeval drawtimeout, *tv = NULL, now, last, lastblink; /* Waiting for window mapping */ while(1) { XNextEvent(xw.dpy, &ev); if(ev.type == ConfigureNotify) { w = ev.xconfigure.width; h = ev.xconfigure.height; } else if(ev.type == MapNotify) { break; } } if(!xw.isfixed) cresize(w, h); else cresize(xw.fw, xw.fh); ttynew(); gettimeofday(&lastblink, NULL); gettimeofday(&last, NULL); for(xev = actionfps;;) { FD_ZERO(&rfd); FD_SET(cmdfd, &rfd); FD_SET(xfd, &rfd); if(select(MAX(xfd, cmdfd)+1, &rfd, NULL, NULL, tv) < 0) { if(errno == EINTR) continue; die("select failed: %s\n", SERRNO); } if(FD_ISSET(cmdfd, &rfd)) { ttyread(); if(blinktimeout) { blinkset = tattrset(ATTR_BLINK); if(!blinkset) MODBIT(term.mode, 0, MODE_BLINK); } } if(FD_ISSET(xfd, &rfd)) xev = actionfps; gettimeofday(&now, NULL); drawtimeout.tv_sec = 0; drawtimeout.tv_usec = (1000/xfps) * 1000; tv = &drawtimeout; dodraw = 0; if(blinktimeout && TIMEDIFF(now, lastblink) > blinktimeout) { tsetdirtattr(ATTR_BLINK); term.mode ^= MODE_BLINK; gettimeofday(&lastblink, NULL); dodraw = 1; } if(TIMEDIFF(now, last) \ > (xev? (1000/xfps) : (1000/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(cmdfd, &rfd) && !FD_ISSET(xfd, &rfd)) { if(blinkset) { if(TIMEDIFF(now, lastblink) \ > blinktimeout) { drawtimeout.tv_usec = 1; } else { drawtimeout.tv_usec = (1000 * \ (blinktimeout - \ TIMEDIFF(now, lastblink))); } } else { tv = NULL; } } } } } void usage(void) { die("%s " VERSION " (c) 2010-2013 st engineers\n" \ "usage: st [-a] [-v] [-c class] [-f font] [-g geometry] [-o file]" \ " [-t title] [-w windowid] [-e command ...]\n", argv0); } int main(int argc, char *argv[]) { int bitm, xr, yr; uint wr, hr; char *titles; xw.fw = xw.fh = xw.fx = xw.fy = 0; xw.isfixed = False; ARGBEGIN { case 'a': allowaltscreen = false; break; case 'c': opt_class = EARGF(usage()); break; case 'e': /* eat all remaining arguments */ if(argc > 1) { opt_cmd = &argv[1]; if(argv[1] != NULL && opt_title == NULL) { titles = strdup(argv[1]); opt_title = basename(titles); } } goto run; case 'f': opt_font = EARGF(usage()); break; case 'g': bitm = XParseGeometry(EARGF(usage()), &xr, &yr, &wr, &hr); if(bitm & XValue) xw.fx = xr; if(bitm & YValue) xw.fy = yr; if(bitm & WidthValue) xw.fw = (int)wr; if(bitm & HeightValue) xw.fh = (int)hr; if(bitm & XNegative && xw.fx == 0) xw.fx = -1; if(bitm & YNegative && xw.fy == 0) xw.fy = -1; if(xw.fh != 0 && xw.fw != 0) xw.isfixed = True; break; case 'o': opt_io = EARGF(usage()); break; case 't': opt_title = EARGF(usage()); break; case 'w': opt_embed = EARGF(usage()); break; case 'v': default: usage(); } ARGEND; run: setlocale(LC_CTYPE, ""); XSetLocaleModifiers(""); tnew(80, 24); xinit(); selinit(); run(); return 0; } stterm-0.4.1+20130921+giteeae9b0/st.info000066400000000000000000000064511222007470000171440ustar00rootroot00000000000000st| simpleterm, acsc=``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~, 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, 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\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~, kich1=\E[2~, knp=\E[6~, kmous=\E[M, kpp=\E[5~, lines#24, mir, msgr, ncv#3, op=\E[39;49m, pairs#64, 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[m, 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;, ul, xenl, vpa=\E[%i%p1%dd, st-256color| simpleterm with 256 colors, use=st, colors#256, pairs#32767, # Nicked from xterm-256color 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,