add patches

st: guard tsetdirt() against zero-sized terminal
tsetdirt() assumes term.row > 0. During early init or resize paths this may not hold, leading to out-of-bounds access. Bail out early if there are no rows.
2026-02-26 11:54:02 +01:00 · 2026-01-16 14:12:07 +01:00 · 2025-12-02 20:09:47 +01:00 · 2025-08-09 14:35:14 +02:00 · 2025-08-09 14:22:28 +02:00 · 2025-08-09 12:34:01 +02:00
17 changed files with 5894 additions and 178 deletions
--- a/5
+++ b/5
@ -4,7 +4,7 @@

 include config.mk

-SRC = st.c x.c
+SRC = st.c x.c hb.c
 OBJ = $(SRC:.c=.o)

 all: st
@ -16,7 +16,8 @@ config.h:
 	$(CC) $(STCFLAGS) -c $<

 st.o: config.h st.h win.h
-x.o: arg.h config.h st.h win.h
+x.o: arg.h config.h st.h win.h hb.h
+hb.o: st.h

 $(OBJ): config.h config.mk

--- a/config.def.h
+++ b/config.def.h
@ -93,6 +93,9 @@ char *termname = "st-256color";
 */
 unsigned int tabspaces = 8;

+/* bg opacity */
+float alpha = 0.8;
+
 /* Terminal colors (16 first used in escape sequence) */
 static const char *colorname[] = {
 	/* 8 normal colors */
@ -176,6 +179,8 @@ static uint forcemousemod = ShiftMask;
 */
 static MouseShortcut mshortcuts[] = {
 	/* mask                 button   function        argument       release */
+	{ ShiftMask,            Button4, kscrollup,      {.i = 1} },
+	{ ShiftMask,            Button5, kscrolldown,    {.i = 1} },
 	{ XK_ANY_MOD,           Button2, selpaste,       {.i = 0},      1 },
 	{ ShiftMask,            Button4, ttysend,        {.s = "\033[5;2~"} },
 	{ XK_ANY_MOD,           Button4, ttysend,        {.s = "\031"} },
@ -201,6 +206,8 @@ static Shortcut shortcuts[] = {
 	{ TERMMOD,              XK_Y,           selpaste,       {.i =  0} },
 	{ ShiftMask,            XK_Insert,      selpaste,       {.i =  0} },
 	{ TERMMOD,              XK_Num_Lock,    numlock,        {.i =  0} },
+	{ ShiftMask,            XK_Page_Up,     kscrollup,      {.i = -1} },
+    { ShiftMask,            XK_Page_Down,   kscrolldown,    {.i = -1} },
 };

 /*
--- a/config.h
+++ b/config.h
@ -0,0 +1,467 @@
+/* See LICENSE file for copyright and license details. */
+
+/*
+ * appearance
+ *
+ * font: see http://freedesktop.org/software/fontconfig/fontconfig-user.html
+ */
+static char *font = "FiraCode Nerd Font Mono:pixelsize=12:antialias=true:autohint=true";
+static int borderpx = 14;
+
+/*
+ * What program is execed by st depends of these precedence rules:
+ * 1: program passed with -e
+ * 2: scroll and/or utmp
+ * 3: SHELL environment variable
+ * 4: value of shell in /etc/passwd
+ * 5: value of shell in config.h
+ */
+static char *shell = "/bin/sh";
+char *utmp = NULL;
+/* scroll program: to enable use a string like "scroll" */
+char *scroll = NULL;
+char *stty_args = "stty raw pass8 nl -echo -iexten -cstopb 38400";
+
+/* identification sequence returned in DA and DECID */
+char *vtiden = "\033[?6c";
+
+/* Kerning / character bounding-box multipliers */
+static float cwscale = 1.0;
+static float chscale = 1.0;
+
+/*
+ * word delimiter string
+ *
+ * More advanced example: L" `'\"()[]{}"
+ */
+wchar_t *worddelimiters = L" ";
+
+/* selection timeouts (in milliseconds) */
+static unsigned int doubleclicktimeout = 300;
+static unsigned int tripleclicktimeout = 600;
+
+/* alt screens */
+int allowaltscreen = 1;
+
+/* allow certain non-interactive (insecure) window operations such as:
+   setting the clipboard text */
+int allowwindowops = 0;
+
+/*
+ * draw latency range in ms - from new content/keypress/etc until drawing.
+ * within this range, st draws when content stops arriving (idle). mostly it's
+ * near minlatency, but it waits longer for slow updates to avoid partial draw.
+ * low minlatency will tear/flicker more, as it can "detect" idle too early.
+ */
+static double minlatency = 2;
+static double maxlatency = 33;
+
+/*
+ * blinking timeout (set to 0 to disable blinking) for the terminal blinking
+ * attribute.
+ */
+static unsigned int blinktimeout = 800;
+
+/*
+ * thickness of underline and bar cursors
+ */
+static unsigned int cursorthickness = 2;
+
+/*
+ * bell volume. It must be a value between -100 and 100. Use 0 for disabling
+ * it
+ */
+static int bellvolume = 0;
+
+/* default TERM value */
+char *termname = "st-256color";
+
+/*
+ * spaces per tab
+ *
+ * When you are changing this value, don't forget to adapt the »it« value in
+ * the st.info and appropriately install the st.info in the environment where
+ * you use this st version.
+ *
+ *	it#$tabspaces,
+ *
+ * Secondly make sure your kernel is not expanding tabs. When running `stty
+ * -a` »tab0« should appear. You can tell the terminal to not expand tabs by
+ *  running following command:
+ *
+ *	stty tabs
+ */
+unsigned int tabspaces = 8;
+
+/* bg opacity */
+float alpha = 0.8;
+
+/* Terminal colors (16 first used in escape sequence) */
+static const char *colorname[] = {
+    /* 8 normal colors */
+    "black",
+    "red3",
+    "green3",
+    "yellow3",
+    "blue2",
+    "magenta3",
+    "cyan3",
+    "gray90",
+
+    /* 8 bright colors */
+    "gray50",
+    "red",
+    "green",
+    "yellow",
+    "#5c5cff",
+    "magenta",
+    "cyan",
+    "white",
+
+    [255] = 0,
+
+    /* more colors can be added after 255 to use with DefaultXX */
+    "#cccccc",
+    "#555555",
+    "gray90", /* default foreground colour */
+    "black",  /* default background colour */
+};
+
+/*
+ * Default colors (colorname index)
+ * foreground, background, cursor, reverse cursor
+ */
+unsigned int defaultfg = 258;
+unsigned int defaultbg = 259;
+unsigned int defaultcs = 256;
+static unsigned int defaultrcs = 257;
+
+/*
+ * Default shape of cursor
+ * 2: Block ("█")
+ * 4: Underline ("_")
+ * 6: Bar ("|")
+ * 7: Snowman ("☃")
+ */
+static unsigned int cursorshape = 4;
+
+/*
+ * Default columns and rows numbers
+ */
+
+static unsigned int cols = 80;
+static unsigned int rows = 24;
+
+/*
+ * Default colour and shape of the mouse cursor
+ */
+static unsigned int mouseshape = XC_xterm;
+static unsigned int mousefg = 7;
+static unsigned int mousebg = 0;
+
+/*
+ * Color used to display font attributes when fontconfig selected a font which
+ * doesn't match the ones requested.
+ */
+static unsigned int defaultattr = 11;
+
+/*
+ * Force mouse select/shortcuts while mask is active (when MODE_MOUSE is set).
+ * Note that if you want to use ShiftMask with selmasks, set this to an other
+ * modifier, set to 0 to not use it.
+ */
+static uint forcemousemod = ShiftMask;
+
+/*
+ * Internal mouse shortcuts.
+ * Beware that overloading Button1 will disable the selection.
+ */
+static MouseShortcut mshortcuts[] = {
+    /* mask                 button   function        argument       release */
+    {ShiftMask, Button4, kscrollup, {.i = 1}},     {ShiftMask, Button5, kscrolldown, {.i = 1}},       {XK_ANY_MOD, Button2, selpaste, {.i = 0}, 1},  {ShiftMask, Button4, ttysend, {.s = "\033[5;2~"}},
+    {XK_ANY_MOD, Button4, ttysend, {.s = "\031"}}, {ShiftMask, Button5, ttysend, {.s = "\033[6;2~"}}, {XK_ANY_MOD, Button5, ttysend, {.s = "\005"}},
+};
+
+/* Internal keyboard shortcuts. */
+#define MODKEY Mod1Mask
+#define TERMMOD (ControlMask | ShiftMask)
+
+static Shortcut shortcuts[] = {
+    /* mask                 keysym          function        argument */
+    {XK_ANY_MOD, XK_Break, sendbreak, {.i = 0}},   {ControlMask, XK_Print, toggleprinter, {.i = 0}},
+    {ShiftMask, XK_Print, printscreen, {.i = 0}},  {XK_ANY_MOD, XK_Print, printsel, {.i = 0}},
+    {TERMMOD, XK_Prior, zoom, {.f = +1}},          {TERMMOD, XK_Next, zoom, {.f = -1}},
+    {TERMMOD, XK_Home, zoomreset, {.f = 0}},       {TERMMOD, XK_C, clipcopy, {.i = 0}},
+    {TERMMOD, XK_V, clippaste, {.i = 0}},          {TERMMOD, XK_Y, selpaste, {.i = 0}},
+    {ShiftMask, XK_Insert, selpaste, {.i = 0}},    {TERMMOD, XK_Num_Lock, numlock, {.i = 0}},
+    {ShiftMask, XK_Page_Up, kscrollup, {.i = -1}}, {ShiftMask, XK_Page_Down, kscrolldown, {.i = -1}},
+};
+
+/*
+ * Special keys (change & recompile st.info accordingly)
+ *
+ * Mask value:
+ * * Use XK_ANY_MOD to match the key no matter modifiers state
+ * * Use XK_NO_MOD to match the key alone (no modifiers)
+ * appkey value:
+ * * 0: no value
+ * * > 0: keypad application mode enabled
+ * *   = 2: term.numlock = 1
+ * * < 0: keypad application mode disabled
+ * appcursor value:
+ * * 0: no value
+ * * > 0: cursor application mode enabled
+ * * < 0: cursor application mode disabled
+ *
+ * Be careful with the order of the definitions because st searches in
+ * this table sequentially, so any XK_ANY_MOD must be in the last
+ * position for a key.
+ */
+
+/*
+ * If you want keys other than the X11 function keys (0xFD00 - 0xFFFF)
+ * to be mapped below, add them to this array.
+ */
+static KeySym mappedkeys[] = {-1};
+
+/*
+ * State bits to ignore when matching key or button events.  By default,
+ * numlock (Mod2Mask) and keyboard layout (XK_SWITCH_MOD) are ignored.
+ */
+static uint ignoremod = Mod2Mask | XK_SWITCH_MOD;
+
+/*
+ * This is the huge key array which defines all compatibility to the Linux
+ * world. Please decide about changes wisely.
+ */
+static Key key[] = {
+    /* keysym           mask            string      appkey appcursor */
+    {XK_KP_Home, ShiftMask, "\033[2J", 0, -1},
+    {XK_KP_Home, ShiftMask, "\033[1;2H", 0, +1},
+    {XK_KP_Home, XK_ANY_MOD, "\033[H", 0, -1},
+    {XK_KP_Home, XK_ANY_MOD, "\033[1~", 0, +1},
+    {XK_KP_Up, XK_ANY_MOD, "\033Ox", +1, 0},
+    {XK_KP_Up, XK_ANY_MOD, "\033[A", 0, -1},
+    {XK_KP_Up, XK_ANY_MOD, "\033OA", 0, +1},
+    {XK_KP_Down, XK_ANY_MOD, "\033Or", +1, 0},
+    {XK_KP_Down, XK_ANY_MOD, "\033[B", 0, -1},
+    {XK_KP_Down, XK_ANY_MOD, "\033OB", 0, +1},
+    {XK_KP_Left, XK_ANY_MOD, "\033Ot", +1, 0},
+    {XK_KP_Left, XK_ANY_MOD, "\033[D", 0, -1},
+    {XK_KP_Left, XK_ANY_MOD, "\033OD", 0, +1},
+    {XK_KP_Right, XK_ANY_MOD, "\033Ov", +1, 0},
+    {XK_KP_Right, XK_ANY_MOD, "\033[C", 0, -1},
+    {XK_KP_Right, XK_ANY_MOD, "\033OC", 0, +1},
+    {XK_KP_Prior, ShiftMask, "\033[5;2~", 0, 0},
+    {XK_KP_Prior, XK_ANY_MOD, "\033[5~", 0, 0},
+    {XK_KP_Begin, XK_ANY_MOD, "\033[E", 0, 0},
+    {XK_KP_End, ControlMask, "\033[J", -1, 0},
+    {XK_KP_End, ControlMask, "\033[1;5F", +1, 0},
+    {XK_KP_End, ShiftMask, "\033[K", -1, 0},
+    {XK_KP_End, ShiftMask, "\033[1;2F", +1, 0},
+    {XK_KP_End, XK_ANY_MOD, "\033[4~", 0, 0},
+    {XK_KP_Next, ShiftMask, "\033[6;2~", 0, 0},
+    {XK_KP_Next, XK_ANY_MOD, "\033[6~", 0, 0},
+    {XK_KP_Insert, ShiftMask, "\033[2;2~", +1, 0},
+    {XK_KP_Insert, ShiftMask, "\033[4l", -1, 0},
+    {XK_KP_Insert, ControlMask, "\033[L", -1, 0},
+    {XK_KP_Insert, ControlMask, "\033[2;5~", +1, 0},
+    {XK_KP_Insert, XK_ANY_MOD, "\033[4h", -1, 0},
+    {XK_KP_Insert, XK_ANY_MOD, "\033[2~", +1, 0},
+    {XK_KP_Delete, ControlMask, "\033[M", -1, 0},
+    {XK_KP_Delete, ControlMask, "\033[3;5~", +1, 0},
+    {XK_KP_Delete, ShiftMask, "\033[2K", -1, 0},
+    {XK_KP_Delete, ShiftMask, "\033[3;2~", +1, 0},
+    {XK_KP_Delete, XK_ANY_MOD, "\033[P", -1, 0},
+    {XK_KP_Delete, XK_ANY_MOD, "\033[3~", +1, 0},
+    {XK_KP_Multiply, XK_ANY_MOD, "\033Oj", +2, 0},
+    {XK_KP_Add, XK_ANY_MOD, "\033Ok", +2, 0},
+    {XK_KP_Enter, XK_ANY_MOD, "\033OM", +2, 0},
+    {XK_KP_Enter, XK_ANY_MOD, "\r", -1, 0},
+    {XK_KP_Subtract, XK_ANY_MOD, "\033Om", +2, 0},
+    {XK_KP_Decimal, XK_ANY_MOD, "\033On", +2, 0},
+    {XK_KP_Divide, XK_ANY_MOD, "\033Oo", +2, 0},
+    {XK_KP_0, XK_ANY_MOD, "\033Op", +2, 0},
+    {XK_KP_1, XK_ANY_MOD, "\033Oq", +2, 0},
+    {XK_KP_2, XK_ANY_MOD, "\033Or", +2, 0},
+    {XK_KP_3, XK_ANY_MOD, "\033Os", +2, 0},
+    {XK_KP_4, XK_ANY_MOD, "\033Ot", +2, 0},
+    {XK_KP_5, XK_ANY_MOD, "\033Ou", +2, 0},
+    {XK_KP_6, XK_ANY_MOD, "\033Ov", +2, 0},
+    {XK_KP_7, XK_ANY_MOD, "\033Ow", +2, 0},
+    {XK_KP_8, XK_ANY_MOD, "\033Ox", +2, 0},
+    {XK_KP_9, XK_ANY_MOD, "\033Oy", +2, 0},
+    {XK_Up, ShiftMask, "\033[1;2A", 0, 0},
+    {XK_Up, Mod1Mask, "\033[1;3A", 0, 0},
+    {XK_Up, ShiftMask | Mod1Mask, "\033[1;4A", 0, 0},
+    {XK_Up, ControlMask, "\033[1;5A", 0, 0},
+    {XK_Up, ShiftMask | ControlMask, "\033[1;6A", 0, 0},
+    {XK_Up, ControlMask | Mod1Mask, "\033[1;7A", 0, 0},
+    {XK_Up, ShiftMask | ControlMask | Mod1Mask, "\033[1;8A", 0, 0},
+    {XK_Up, XK_ANY_MOD, "\033[A", 0, -1},
+    {XK_Up, XK_ANY_MOD, "\033OA", 0, +1},
+    {XK_Down, ShiftMask, "\033[1;2B", 0, 0},
+    {XK_Down, Mod1Mask, "\033[1;3B", 0, 0},
+    {XK_Down, ShiftMask | Mod1Mask, "\033[1;4B", 0, 0},
+    {XK_Down, ControlMask, "\033[1;5B", 0, 0},
+    {XK_Down, ShiftMask | ControlMask, "\033[1;6B", 0, 0},
+    {XK_Down, ControlMask | Mod1Mask, "\033[1;7B", 0, 0},
+    {XK_Down, ShiftMask | ControlMask | Mod1Mask, "\033[1;8B", 0, 0},
+    {XK_Down, XK_ANY_MOD, "\033[B", 0, -1},
+    {XK_Down, XK_ANY_MOD, "\033OB", 0, +1},
+    {XK_Left, ShiftMask, "\033[1;2D", 0, 0},
+    {XK_Left, Mod1Mask, "\033[1;3D", 0, 0},
+    {XK_Left, ShiftMask | Mod1Mask, "\033[1;4D", 0, 0},
+    {XK_Left, ControlMask, "\033[1;5D", 0, 0},
+    {XK_Left, ShiftMask | ControlMask, "\033[1;6D", 0, 0},
+    {XK_Left, ControlMask | Mod1Mask, "\033[1;7D", 0, 0},
+    {XK_Left, ShiftMask | ControlMask | Mod1Mask, "\033[1;8D", 0, 0},
+    {XK_Left, XK_ANY_MOD, "\033[D", 0, -1},
+    {XK_Left, XK_ANY_MOD, "\033OD", 0, +1},
+    {XK_Right, ShiftMask, "\033[1;2C", 0, 0},
+    {XK_Right, Mod1Mask, "\033[1;3C", 0, 0},
+    {XK_Right, ShiftMask | Mod1Mask, "\033[1;4C", 0, 0},
+    {XK_Right, ControlMask, "\033[1;5C", 0, 0},
+    {XK_Right, ShiftMask | ControlMask, "\033[1;6C", 0, 0},
+    {XK_Right, ControlMask | Mod1Mask, "\033[1;7C", 0, 0},
+    {XK_Right, ShiftMask | ControlMask | Mod1Mask, "\033[1;8C", 0, 0},
+    {XK_Right, XK_ANY_MOD, "\033[C", 0, -1},
+    {XK_Right, XK_ANY_MOD, "\033OC", 0, +1},
+    {XK_ISO_Left_Tab, ShiftMask, "\033[Z", 0, 0},
+    {XK_Return, Mod1Mask, "\033\r", 0, 0},
+    {XK_Return, XK_ANY_MOD, "\r", 0, 0},
+    {XK_Insert, ShiftMask, "\033[4l", -1, 0},
+    {XK_Insert, ShiftMask, "\033[2;2~", +1, 0},
+    {XK_Insert, ControlMask, "\033[L", -1, 0},
+    {XK_Insert, ControlMask, "\033[2;5~", +1, 0},
+    {XK_Insert, XK_ANY_MOD, "\033[4h", -1, 0},
+    {XK_Insert, XK_ANY_MOD, "\033[2~", +1, 0},
+    {XK_Delete, ControlMask, "\033[M", -1, 0},
+    {XK_Delete, ControlMask, "\033[3;5~", +1, 0},
+    {XK_Delete, ShiftMask, "\033[2K", -1, 0},
+    {XK_Delete, ShiftMask, "\033[3;2~", +1, 0},
+    {XK_Delete, XK_ANY_MOD, "\033[P", -1, 0},
+    {XK_Delete, XK_ANY_MOD, "\033[3~", +1, 0},
+    {XK_BackSpace, XK_NO_MOD, "\177", 0, 0},
+    {XK_BackSpace, Mod1Mask, "\033\177", 0, 0},
+    {XK_Home, ShiftMask, "\033[2J", 0, -1},
+    {XK_Home, ShiftMask, "\033[1;2H", 0, +1},
+    {XK_Home, XK_ANY_MOD, "\033[H", 0, -1},
+    {XK_Home, XK_ANY_MOD, "\033[1~", 0, +1},
+    {XK_End, ControlMask, "\033[J", -1, 0},
+    {XK_End, ControlMask, "\033[1;5F", +1, 0},
+    {XK_End, ShiftMask, "\033[K", -1, 0},
+    {XK_End, ShiftMask, "\033[1;2F", +1, 0},
+    {XK_End, XK_ANY_MOD, "\033[4~", 0, 0},
+    {XK_Prior, ControlMask, "\033[5;5~", 0, 0},
+    {XK_Prior, ShiftMask, "\033[5;2~", 0, 0},
+    {XK_Prior, XK_ANY_MOD, "\033[5~", 0, 0},
+    {XK_Next, ControlMask, "\033[6;5~", 0, 0},
+    {XK_Next, ShiftMask, "\033[6;2~", 0, 0},
+    {XK_Next, XK_ANY_MOD, "\033[6~", 0, 0},
+    {XK_F1, XK_NO_MOD, "\033OP", 0, 0},
+    {XK_F1, /* F13 */ ShiftMask, "\033[1;2P", 0, 0},
+    {XK_F1, /* F25 */ ControlMask, "\033[1;5P", 0, 0},
+    {XK_F1, /* F37 */ Mod4Mask, "\033[1;6P", 0, 0},
+    {XK_F1, /* F49 */ Mod1Mask, "\033[1;3P", 0, 0},
+    {XK_F1, /* F61 */ Mod3Mask, "\033[1;4P", 0, 0},
+    {XK_F2, XK_NO_MOD, "\033OQ", 0, 0},
+    {XK_F2, /* F14 */ ShiftMask, "\033[1;2Q", 0, 0},
+    {XK_F2, /* F26 */ ControlMask, "\033[1;5Q", 0, 0},
+    {XK_F2, /* F38 */ Mod4Mask, "\033[1;6Q", 0, 0},
+    {XK_F2, /* F50 */ Mod1Mask, "\033[1;3Q", 0, 0},
+    {XK_F2, /* F62 */ Mod3Mask, "\033[1;4Q", 0, 0},
+    {XK_F3, XK_NO_MOD, "\033OR", 0, 0},
+    {XK_F3, /* F15 */ ShiftMask, "\033[1;2R", 0, 0},
+    {XK_F3, /* F27 */ ControlMask, "\033[1;5R", 0, 0},
+    {XK_F3, /* F39 */ Mod4Mask, "\033[1;6R", 0, 0},
+    {XK_F3, /* F51 */ Mod1Mask, "\033[1;3R", 0, 0},
+    {XK_F3, /* F63 */ Mod3Mask, "\033[1;4R", 0, 0},
+    {XK_F4, XK_NO_MOD, "\033OS", 0, 0},
+    {XK_F4, /* F16 */ ShiftMask, "\033[1;2S", 0, 0},
+    {XK_F4, /* F28 */ ControlMask, "\033[1;5S", 0, 0},
+    {XK_F4, /* F40 */ Mod4Mask, "\033[1;6S", 0, 0},
+    {XK_F4, /* F52 */ Mod1Mask, "\033[1;3S", 0, 0},
+    {XK_F5, XK_NO_MOD, "\033[15~", 0, 0},
+    {XK_F5, /* F17 */ ShiftMask, "\033[15;2~", 0, 0},
+    {XK_F5, /* F29 */ ControlMask, "\033[15;5~", 0, 0},
+    {XK_F5, /* F41 */ Mod4Mask, "\033[15;6~", 0, 0},
+    {XK_F5, /* F53 */ Mod1Mask, "\033[15;3~", 0, 0},
+    {XK_F6, XK_NO_MOD, "\033[17~", 0, 0},
+    {XK_F6, /* F18 */ ShiftMask, "\033[17;2~", 0, 0},
+    {XK_F6, /* F30 */ ControlMask, "\033[17;5~", 0, 0},
+    {XK_F6, /* F42 */ Mod4Mask, "\033[17;6~", 0, 0},
+    {XK_F6, /* F54 */ Mod1Mask, "\033[17;3~", 0, 0},
+    {XK_F7, XK_NO_MOD, "\033[18~", 0, 0},
+    {XK_F7, /* F19 */ ShiftMask, "\033[18;2~", 0, 0},
+    {XK_F7, /* F31 */ ControlMask, "\033[18;5~", 0, 0},
+    {XK_F7, /* F43 */ Mod4Mask, "\033[18;6~", 0, 0},
+    {XK_F7, /* F55 */ Mod1Mask, "\033[18;3~", 0, 0},
+    {XK_F8, XK_NO_MOD, "\033[19~", 0, 0},
+    {XK_F8, /* F20 */ ShiftMask, "\033[19;2~", 0, 0},
+    {XK_F8, /* F32 */ ControlMask, "\033[19;5~", 0, 0},
+    {XK_F8, /* F44 */ Mod4Mask, "\033[19;6~", 0, 0},
+    {XK_F8, /* F56 */ Mod1Mask, "\033[19;3~", 0, 0},
+    {XK_F9, XK_NO_MOD, "\033[20~", 0, 0},
+    {XK_F9, /* F21 */ ShiftMask, "\033[20;2~", 0, 0},
+    {XK_F9, /* F33 */ ControlMask, "\033[20;5~", 0, 0},
+    {XK_F9, /* F45 */ Mod4Mask, "\033[20;6~", 0, 0},
+    {XK_F9, /* F57 */ Mod1Mask, "\033[20;3~", 0, 0},
+    {XK_F10, XK_NO_MOD, "\033[21~", 0, 0},
+    {XK_F10, /* F22 */ ShiftMask, "\033[21;2~", 0, 0},
+    {XK_F10, /* F34 */ ControlMask, "\033[21;5~", 0, 0},
+    {XK_F10, /* F46 */ Mod4Mask, "\033[21;6~", 0, 0},
+    {XK_F10, /* F58 */ Mod1Mask, "\033[21;3~", 0, 0},
+    {XK_F11, XK_NO_MOD, "\033[23~", 0, 0},
+    {XK_F11, /* F23 */ ShiftMask, "\033[23;2~", 0, 0},
+    {XK_F11, /* F35 */ ControlMask, "\033[23;5~", 0, 0},
+    {XK_F11, /* F47 */ Mod4Mask, "\033[23;6~", 0, 0},
+    {XK_F11, /* F59 */ Mod1Mask, "\033[23;3~", 0, 0},
+    {XK_F12, XK_NO_MOD, "\033[24~", 0, 0},
+    {XK_F12, /* F24 */ ShiftMask, "\033[24;2~", 0, 0},
+    {XK_F12, /* F36 */ ControlMask, "\033[24;5~", 0, 0},
+    {XK_F12, /* F48 */ Mod4Mask, "\033[24;6~", 0, 0},
+    {XK_F12, /* F60 */ Mod1Mask, "\033[24;3~", 0, 0},
+    {XK_F13, XK_NO_MOD, "\033[1;2P", 0, 0},
+    {XK_F14, XK_NO_MOD, "\033[1;2Q", 0, 0},
+    {XK_F15, XK_NO_MOD, "\033[1;2R", 0, 0},
+    {XK_F16, XK_NO_MOD, "\033[1;2S", 0, 0},
+    {XK_F17, XK_NO_MOD, "\033[15;2~", 0, 0},
+    {XK_F18, XK_NO_MOD, "\033[17;2~", 0, 0},
+    {XK_F19, XK_NO_MOD, "\033[18;2~", 0, 0},
+    {XK_F20, XK_NO_MOD, "\033[19;2~", 0, 0},
+    {XK_F21, XK_NO_MOD, "\033[20;2~", 0, 0},
+    {XK_F22, XK_NO_MOD, "\033[21;2~", 0, 0},
+    {XK_F23, XK_NO_MOD, "\033[23;2~", 0, 0},
+    {XK_F24, XK_NO_MOD, "\033[24;2~", 0, 0},
+    {XK_F25, XK_NO_MOD, "\033[1;5P", 0, 0},
+    {XK_F26, XK_NO_MOD, "\033[1;5Q", 0, 0},
+    {XK_F27, XK_NO_MOD, "\033[1;5R", 0, 0},
+    {XK_F28, XK_NO_MOD, "\033[1;5S", 0, 0},
+    {XK_F29, XK_NO_MOD, "\033[15;5~", 0, 0},
+    {XK_F30, XK_NO_MOD, "\033[17;5~", 0, 0},
+    {XK_F31, XK_NO_MOD, "\033[18;5~", 0, 0},
+    {XK_F32, XK_NO_MOD, "\033[19;5~", 0, 0},
+    {XK_F33, XK_NO_MOD, "\033[20;5~", 0, 0},
+    {XK_F34, XK_NO_MOD, "\033[21;5~", 0, 0},
+    {XK_F35, XK_NO_MOD, "\033[23;5~", 0, 0},
+};
+
+/*
+ * Selection types' masks.
+ * Use the same masks as usual.
+ * Button1Mask is always unset, to make masks match between ButtonPress.
+ * ButtonRelease and MotionNotify.
+ * If no match is found, regular selection is used.
+ */
+static uint selmasks[] = {
+    [SEL_RECTANGULAR] = Mod1Mask,
+};
+
+/*
+ * Printable characters in ASCII, used to estimate the advance width
+ * of single wide characters.
+ */
+static char ascii_printable[] = " !\"#$%&'()*+,-./0123456789:;<=>?"
+                                "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
+                                "`abcdefghijklmnopqrstuvwxyz{|}~";
--- a/config.mk
+++ b/config.mk
@ -1,5 +1,5 @@
 # st version
-VERSION = 0.9.2
+VERSION = 0.9.3

 # Customize below to fit your system

@ -15,10 +15,12 @@ PKG_CONFIG = pkg-config
 # includes and libs
 INCS = -I$(X11INC) \
       `$(PKG_CONFIG) --cflags fontconfig` \
-       `$(PKG_CONFIG) --cflags freetype2`
-LIBS = -L$(X11LIB) -lm -lrt -lX11 -lutil -lXft \
+       `$(PKG_CONFIG) --cflags freetype2` \
+       `$(PKG_CONFIG) --cflags harfbuzz`
+LIBS = -L$(X11LIB) -lm -lrt -lX11 -lutil -lXft -lXrender \
       `$(PKG_CONFIG) --libs fontconfig` \
-       `$(PKG_CONFIG) --libs freetype2`
+       `$(PKG_CONFIG) --libs freetype2` \
+       `$(PKG_CONFIG) --libs harfbuzz`

 # flags
 STCPPFLAGS = -DVERSION=\"$(VERSION)\" -D_XOPEN_SOURCE=600
@ -29,7 +31,8 @@ STLDFLAGS = $(LIBS) $(LDFLAGS)
 #CPPFLAGS = -DVERSION=\"$(VERSION)\" -D_XOPEN_SOURCE=600 -D_BSD_SOURCE
 #LIBS = -L$(X11LIB) -lm -lX11 -lutil -lXft \
 #       `$(PKG_CONFIG) --libs fontconfig` \
-#       `$(PKG_CONFIG) --libs freetype2`
+#       `$(PKG_CONFIG) --libs freetype2` \
+#       `$(PKG_CONFIG) --libs harfbuzz`
 #MANPREFIX = ${PREFIX}/man

 # compiler and linker
--- a/config.mk.orig
+++ b/config.mk.orig
@ -0,0 +1,36 @@
+# st version
+VERSION = 0.9.3
+
+# Customize below to fit your system
+
+# paths
+PREFIX = /usr/local
+MANPREFIX = $(PREFIX)/share/man
+
+X11INC = /usr/X11R6/include
+X11LIB = /usr/X11R6/lib
+
+PKG_CONFIG = pkg-config
+
+# includes and libs
+INCS = -I$(X11INC) \
+       `$(PKG_CONFIG) --cflags fontconfig` \
+       `$(PKG_CONFIG) --cflags freetype2`
+LIBS = -L$(X11LIB) -lm -lrt -lX11 -lutil -lXft \
+       `$(PKG_CONFIG) --libs fontconfig` \
+       `$(PKG_CONFIG) --libs freetype2`
+
+# flags
+STCPPFLAGS = -DVERSION=\"$(VERSION)\" -D_XOPEN_SOURCE=600
+STCFLAGS = $(INCS) $(STCPPFLAGS) $(CPPFLAGS) $(CFLAGS)
+STLDFLAGS = $(LIBS) $(LDFLAGS)
+
+# OpenBSD:
+#CPPFLAGS = -DVERSION=\"$(VERSION)\" -D_XOPEN_SOURCE=600 -D_BSD_SOURCE
+#LIBS = -L$(X11LIB) -lm -lX11 -lutil -lXft \
+#       `$(PKG_CONFIG) --libs fontconfig` \
+#       `$(PKG_CONFIG) --libs freetype2`
+#MANPREFIX = ${PREFIX}/man
+
+# compiler and linker
+# CC = c99
--- a/hb.c
+++ b/hb.c
@ -0,0 +1,128 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <X11/Xft/Xft.h>
+#include <X11/cursorfont.h>
+#include <hb.h>
+#include <hb-ft.h>
+
+#include "st.h"
+#include "hb.h"
+
+#define FEATURE(c1,c2,c3,c4) { .tag = HB_TAG(c1,c2,c3,c4), .value = 1, .start = HB_FEATURE_GLOBAL_START, .end = HB_FEATURE_GLOBAL_END }
+#define BUFFER_STEP 256
+
+hb_font_t *hbfindfont(XftFont *match);
+
+typedef struct {
+	XftFont *match;
+	hb_font_t *font;
+} HbFontMatch;
+
+typedef struct {
+	size_t capacity;
+	HbFontMatch *fonts;
+} HbFontCache;
+
+static HbFontCache hbfontcache = { 0, NULL };
+
+typedef struct {
+	size_t capacity;
+	Rune *runes;
+} RuneBuffer;
+
+static RuneBuffer hbrunebuffer = { 0, NULL };
+
+/*
+ * Poplulate the array with a list of font features, wrapped in FEATURE macro,
+ * e. g.
+ * FEATURE('c', 'a', 'l', 't'), FEATURE('d', 'l', 'i', 'g')
+ */
+hb_feature_t features[] = {
+	FEATURE('c', 'a', 'l', 't'),
+	FEATURE('d', 'l', 'i', 'g')
+};
+
+void
+hbunloadfonts()
+{
+	for (int i = 0; i < hbfontcache.capacity; i++) {
+		hb_font_destroy(hbfontcache.fonts[i].font);
+		XftUnlockFace(hbfontcache.fonts[i].match);
+	}
+
+	if (hbfontcache.fonts != NULL) {
+		free(hbfontcache.fonts);
+		hbfontcache.fonts = NULL;
+	}
+	hbfontcache.capacity = 0;
+}
+
+hb_font_t *
+hbfindfont(XftFont *match)
+{
+	for (int i = 0; i < hbfontcache.capacity; i++) {
+		if (hbfontcache.fonts[i].match == match)
+			return hbfontcache.fonts[i].font;
+	}
+
+	/* Font not found in cache, caching it now. */
+	hbfontcache.fonts = realloc(hbfontcache.fonts, sizeof(HbFontMatch) * (hbfontcache.capacity + 1));
+	FT_Face face = XftLockFace(match);
+	hb_font_t *font = hb_ft_font_create(face, NULL);
+	if (font == NULL)
+		die("Failed to load Harfbuzz font.");
+
+	hbfontcache.fonts[hbfontcache.capacity].match = match;
+	hbfontcache.fonts[hbfontcache.capacity].font = font;
+	hbfontcache.capacity += 1;
+
+	return font;
+}
+
+void hbtransform(HbTransformData *data, XftFont *xfont, const Glyph *glyphs, int start, int length) {
+	ushort mode = USHRT_MAX;
+	unsigned int glyph_count;
+	int rune_idx, glyph_idx, end = start + length;
+
+	hb_font_t *font = hbfindfont(xfont);
+	if (font == NULL)
+		return;
+
+	hb_buffer_t *buffer = hb_buffer_create();
+	hb_buffer_set_direction(buffer, HB_DIRECTION_LTR);
+	hb_buffer_set_cluster_level(buffer, HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS);
+
+	/* Resize the buffer if required length is larger. */
+	if (hbrunebuffer.capacity < length) {
+		hbrunebuffer.capacity = (length / BUFFER_STEP + 1) * BUFFER_STEP;
+		hbrunebuffer.runes = realloc(hbrunebuffer.runes, hbrunebuffer.capacity * sizeof(Rune));
+	}
+
+	/* Fill buffer with codepoints. */
+	for (rune_idx = 0, glyph_idx = start; glyph_idx < end; glyph_idx++, rune_idx++) {
+		hbrunebuffer.runes[rune_idx] = glyphs[glyph_idx].u;
+		mode = glyphs[glyph_idx].mode;
+		if (mode & ATTR_WDUMMY)
+			hbrunebuffer.runes[rune_idx] = 0x0020;
+	}
+	hb_buffer_add_codepoints(buffer, hbrunebuffer.runes, length, 0, length);
+
+	/* Shape the segment. */
+	hb_shape(font, buffer, features, sizeof(features)/sizeof(hb_feature_t));
+
+	/* Get new glyph info. */
+	hb_glyph_info_t *info = hb_buffer_get_glyph_infos(buffer, &glyph_count);
+	hb_glyph_position_t *pos = hb_buffer_get_glyph_positions(buffer, &glyph_count);
+
+	/* Fill the output. */
+	data->buffer = buffer;
+	data->glyphs = info;
+	data->positions = pos;
+	data->count = glyph_count;
+}
+
+void hbcleanup(HbTransformData *data) {
+	hb_buffer_destroy(data->buffer);
+	memset(data, 0, sizeof(HbTransformData));
+}
--- a/hb.h
+++ b/hb.h
@ -0,0 +1,14 @@
+#include <X11/Xft/Xft.h>
+#include <hb.h>
+#include <hb-ft.h>
+
+typedef struct {
+	hb_buffer_t *buffer;
+	hb_glyph_info_t *glyphs;
+	hb_glyph_position_t *positions;
+	unsigned int count;
+} HbTransformData;
+
+void hbunloadfonts();
+void hbtransform(HbTransformData *, XftFont *, const Glyph *, int, int);
+void hbcleanup(HbTransformData *);
--- a/hb.o
+++ b/hb.o
--- a/BIN
+++ b/BIN
--- a/st.c
+++ b/st.c
@ -35,6 +35,7 @@
 #define ESC_ARG_SIZ   16
 #define STR_BUF_SIZ   ESC_BUF_SIZ
 #define STR_ARG_SIZ   ESC_ARG_SIZ
+#define HISTSIZE      2000

 /* macros */
 #define IS_SET(flag)		((term.mode & (flag)) != 0)
@ -42,6 +43,9 @@
 #define ISCONTROLC1(c)		(BETWEEN(c, 0x80, 0x9f))
 #define ISCONTROL(c)		(ISCONTROLC0(c) || ISCONTROLC1(c))
 #define ISDELIM(u)		(u && wcschr(worddelimiters, u))
+#define TLINE(y)		((y) < term.scr ? term.hist[((y) + term.histi - \
+            term.scr + HISTSIZE + 1) % HISTSIZE] : \
+            term.line[(y) - term.scr])

 enum term_mode {
 	MODE_WRAP        = 1 << 0,
@ -115,6 +119,9 @@ typedef struct {
 	int col;      /* nb col */
 	Line *line;   /* screen */
 	Line *alt;    /* alternate screen */
+	Line hist[HISTSIZE]; /* history buffer */
+	int histi;    /* history index */
+	int scr;      /* scroll back */
 	int *dirty;   /* dirtyness of lines */
 	TCursor c;    /* cursor */
 	int ocx;      /* old cursor col */
@ -185,8 +192,8 @@ static void tnewline(int);
 static void tputtab(int);
 static void tputc(Rune);
 static void treset(void);
-static void tscrollup(int, int);
-static void tscrolldown(int, int);
+static void tscrollup(int, int, int);
+static void tscrolldown(int, int, int);
 static void tsetattr(const int *, int);
 static void tsetchar(Rune, const Glyph *, int, int);
 static void tsetdirt(int, int);
@ -409,10 +416,10 @@ tlinelen(int y)
 {
 	int i = term.col;

-	if (term.line[y][i - 1].mode & ATTR_WRAP)
+	if (TLINE(y)[i - 1].mode & ATTR_WRAP)
 		return i;

-	while (i > 0 && term.line[y][i - 1].u == ' ')
+	while (i > 0 && TLINE(y)[i - 1].u == ' ')
 		--i;

 	return i;
@ -521,7 +528,7 @@ selsnap(int *x, int *y, int direction)
 		 * Snap around if the word wraps around at the end or
 		 * beginning of a line.
 		 */
-		prevgp = &term.line[*y][*x];
+		prevgp = &TLINE(*y)[*x];
 		prevdelim = ISDELIM(prevgp->u);
 		for (;;) {
 			newx = *x + direction;
@ -536,14 +543,14 @@ selsnap(int *x, int *y, int direction)
 					yt = *y, xt = *x;
 				else
 					yt = newy, xt = newx;
-				if (!(term.line[yt][xt].mode & ATTR_WRAP))
+				if (!(TLINE(yt)[xt].mode & ATTR_WRAP))
 					break;
 			}

 			if (newx >= tlinelen(newy))
 				break;

-			gp = &term.line[newy][newx];
+			gp = &TLINE(newy)[newx];
 			delim = ISDELIM(gp->u);
 			if (!(gp->mode & ATTR_WDUMMY) && (delim != prevdelim
 					|| (delim && gp->u != prevgp->u)))
@ -564,14 +571,14 @@ selsnap(int *x, int *y, int direction)
 		*x = (direction < 0) ? 0 : term.col - 1;
 		if (direction < 0) {
 			for (; *y > 0; *y += direction) {
-				if (!(term.line[*y-1][term.col-1].mode
+				if (!(TLINE(*y-1)[term.col-1].mode
 						& ATTR_WRAP)) {
 					break;
 				}
 			}
 		} else if (direction > 0) {
 			for (; *y < term.row-1; *y += direction) {
-				if (!(term.line[*y][term.col-1].mode
+				if (!(TLINE(*y)[term.col-1].mode
 						& ATTR_WRAP)) {
 					break;
 				}
@ -602,13 +609,13 @@ getsel(void)
 		}

 		if (sel.type == SEL_RECTANGULAR) {
-			gp = &term.line[y][sel.nb.x];
+			gp = &TLINE(y)[sel.nb.x];
 			lastx = sel.ne.x;
 		} else {
-			gp = &term.line[y][sel.nb.y == y ? sel.nb.x : 0];
+			gp = &TLINE(y)[sel.nb.y == y ? sel.nb.x : 0];
 			lastx = (sel.ne.y == y) ? sel.ne.x : term.col-1;
 		}
-		last = &term.line[y][MIN(lastx, linelen-1)];
+		last = &TLINE(y)[MIN(lastx, linelen-1)];
 		while (last >= gp && last->u == ' ')
 			--last;

@ -844,6 +851,9 @@ void
 ttywrite(const char *s, size_t n, int may_echo)
 {
 	const char *next;
+	Arg arg = (Arg) { .i = term.scr };
+
+	kscrolldown(&arg);

 	if (may_echo && IS_SET(MODE_ECHO))
 		twrite(s, n, 1);
@ -965,6 +975,9 @@ tsetdirt(int top, int bot)
 {
 	int i;

+	if (term.row <= 0)
+		return;
+
 	LIMIT(top, 0, term.row-1);
 	LIMIT(bot, 0, term.row-1);

@ -1055,13 +1068,53 @@ tswapscreen(void)
 }

 void
-tscrolldown(int orig, int n)
+kscrolldown(const Arg* a)
+{
+	int n = a->i;
+
+	if (n < 0)
+		n = term.row + n;
+
+	if (n > term.scr)
+		n = term.scr;
+
+	if (term.scr > 0) {
+		term.scr -= n;
+		selscroll(0, -n);
+		tfulldirt();
+	}
+}
+
+void
+kscrollup(const Arg* a)
+{
+	int n = a->i;
+
+	if (n < 0)
+		n = term.row + n;
+
+	if (term.scr <= HISTSIZE-n) {
+		term.scr += n;
+		selscroll(0, n);
+		tfulldirt();
+	}
+}
+
+void
+tscrolldown(int orig, int n, int copyhist)
 {
 	int i;
 	Line temp;

 	LIMIT(n, 0, term.bot-orig+1);

+	if (copyhist) {
+		term.histi = (term.histi - 1 + HISTSIZE) % HISTSIZE;
+		temp = term.hist[term.histi];
+		term.hist[term.histi] = term.line[term.bot];
+		term.line[term.bot] = temp;
+	}
+
 	tsetdirt(orig, term.bot-n);
 	tclearregion(0, term.bot-n+1, term.col-1, term.bot);

@ -1071,17 +1124,28 @@ tscrolldown(int orig, int n)
 		term.line[i-n] = temp;
 	}

+	if (term.scr == 0)
 		selscroll(orig, n);
 }

 void
-tscrollup(int orig, int n)
+tscrollup(int orig, int n, int copyhist)
 {
 	int i;
 	Line temp;

 	LIMIT(n, 0, term.bot-orig+1);

+	if (copyhist) {
+		term.histi = (term.histi + 1) % HISTSIZE;
+		temp = term.hist[term.histi];
+		term.hist[term.histi] = term.line[orig];
+		term.line[orig] = temp;
+	}
+
+	if (term.scr > 0 && term.scr < HISTSIZE)
+		term.scr = MIN(term.scr + n, HISTSIZE-1);
+
 	tclearregion(0, orig, term.col-1, orig+n-1);
 	tsetdirt(orig+n, term.bot);

@ -1091,6 +1155,7 @@ tscrollup(int orig, int n)
 		term.line[i+n] = temp;
 	}

+	if (term.scr == 0)
 		selscroll(orig, -n);
 }

@ -1120,7 +1185,7 @@ tnewline(int first_col)
 	int y = term.c.y;

 	if (y == term.bot) {
-		tscrollup(term.top, 1);
+		tscrollup(term.top, 1, 1);
 	} else {
 		y++;
 	}
@ -1288,14 +1353,14 @@ void
 tinsertblankline(int n)
 {
 	if (BETWEEN(term.c.y, term.top, term.bot))
-		tscrolldown(term.c.y, n);
+		tscrolldown(term.c.y, n, 0);
 }

 void
 tdeleteline(int n)
 {
 	if (BETWEEN(term.c.y, term.top, term.bot))
-		tscrollup(term.c.y, n);
+		tscrollup(term.c.y, n, 0);
 }

 int32_t
@ -1420,16 +1485,22 @@ tsetattr(const int *attr, int l)
 			if ((idx = tdefcolor(attr, &i, l)) >= 0)
 				term.c.attr.fg = idx;
 			break;
-		case 39:
+		case 39: /* set foreground color to default */
 			term.c.attr.fg = defaultfg;
 			break;
 		case 48:
 			if ((idx = tdefcolor(attr, &i, l)) >= 0)
 				term.c.attr.bg = idx;
 			break;
-		case 49:
+		case 49: /* set background color to default */
 			term.c.attr.bg = defaultbg;
 			break;
+		case 58:
+			/* This starts a sequence to change the color of
+			 * "underline" pixels. We don't support that and
+			 * instead eat up a following "5;n" or "2;r;g;b". */
+			tdefcolor(attr, &i, l);
+			break;
 		default:
 			if (BETWEEN(attr[i], 30, 37)) {
 				term.c.attr.fg = attr[i] - 30;
@ -1526,7 +1597,7 @@ tsetmode(int priv, int set, const int *args, int narg)
 			case 1006: /* 1006: extended reporting mode */
 				xsetmode(set, MODE_MOUSESGR);
 				break;
-			case 1034:
+			case 1034: /* 1034: enable 8-bit mode for keyboard input */
 				xsetmode(set, MODE_8BIT);
 				break;
 			case 1049: /* swap screen & set/restore cursor as xterm */
@ -1534,8 +1605,8 @@ tsetmode(int priv, int set, const int *args, int narg)
 					break;
 				tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD);
 				/* FALLTHROUGH */
-			case 47: /* swap screen */
-			case 1047:
+			case 47: /* swap screen buffer */
+			case 1047: /* swap screen buffer */
 				if (!allowaltscreen)
 					break;
 				alt = IS_SET(MODE_ALTSCREEN);
@ -1548,7 +1619,7 @@ tsetmode(int priv, int set, const int *args, int narg)
 				if (*args != 1049)
 					break;
 				/* FALLTHROUGH */
-			case 1048:
+			case 1048: /* save/restore cursor (like DECSC/DECRC) */
 				tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD);
 				break;
 			case 2004: /* 2004: bracketed paste mode */
@ -1705,7 +1776,7 @@ csihandle(void)
 			}
 			break;
 		case 1: /* above */
-			if (term.c.y > 1)
+			if (term.c.y > 0)
 				tclearregion(0, 0, term.col-1, term.c.y-1);
 			tclearregion(0, term.c.y, term.c.x, term.c.y);
 			break;
@ -1733,11 +1804,11 @@ csihandle(void)
 	case 'S': /* SU -- Scroll <n> line up */
 		if (csiescseq.priv) break;
 		DEFAULT(csiescseq.arg[0], 1);
-		tscrollup(term.top, csiescseq.arg[0]);
+		tscrollup(term.top, csiescseq.arg[0], 0);
 		break;
 	case 'T': /* SD -- Scroll <n> line down */
 		DEFAULT(csiescseq.arg[0], 1);
-		tscrolldown(term.top, csiescseq.arg[0]);
+		tscrolldown(term.top, csiescseq.arg[0], 0);
 		break;
 	case 'L': /* IL -- Insert <n> blank lines */
 		DEFAULT(csiescseq.arg[0], 1);
@ -1801,7 +1872,11 @@ csihandle(void)
 		tcursor(CURSOR_SAVE);
 		break;
 	case 'u': /* DECRC -- Restore cursor position (ANSI.SYS) */
+		if (csiescseq.priv) {
+			goto unknown;
+		} else {
 			tcursor(CURSOR_LOAD);
+		}
 		break;
 	case ' ':
 		switch (csiescseq.mode[1]) {
@ -1903,7 +1978,7 @@ strhandle(void)
 			if (narg > 1)
 				xsettitle(strescseq.args[1]);
 			return;
-		case 52:
+		case 52: /* manipulate selection data */
 			if (narg > 2 && allowwindowops) {
 				dec = base64dec(strescseq.args[2]);
 				if (dec) {
@ -1914,9 +1989,9 @@ strhandle(void)
 				}
 			}
 			return;
-		case 10:
-		case 11:
-		case 12:
+		case 10: /* set dynamic VT100 text foreground color */
+		case 11: /* set dynamic VT100 text background color */
+		case 12: /* set dynamic text cursor color */
 			if (narg < 2)
 				break;
 			p = strescseq.args[1];
@ -1957,6 +2032,19 @@ strhandle(void)
 				tfulldirt();
 			}
 			return;
+		case 110: /* reset dynamic VT100 text foreground color */
+		case 111: /* reset dynamic VT100 text background color */
+		case 112: /* reset dynamic text cursor color */
+			if (narg != 1)
+				break;
+			if ((j = par - 110) < 0 || j >= LEN(osc_table))
+				break; /* shouldn't be possible */
+			if (xsetcolorname(osc_table[j].idx, NULL)) {
+				fprintf(stderr, "erresc: %s color not found\n", osc_table[j].str);
+			} else {
+				tfulldirt();
+			}
+			return;
 		}
 		break;
 	case 'k': /* old title set compatibility */
@ -2309,7 +2397,7 @@ eschandle(uchar ascii)
 		return 0;
 	case 'D': /* IND -- Linefeed */
 		if (term.c.y == term.bot) {
-			tscrollup(term.top, 1);
+			tscrollup(term.top, 1, 1);
 		} else {
 			tmoveto(term.c.x, term.c.y+1);
 		}
@ -2322,7 +2410,7 @@ eschandle(uchar ascii)
 		break;
 	case 'M': /* RI -- Reverse index */
 		if (term.c.y == term.top) {
-			tscrolldown(term.top, 1);
+			tscrolldown(term.top, 1, 1);
 		} else {
 			tmoveto(term.c.x, term.c.y-1);
 		}
@ -2335,6 +2423,7 @@ eschandle(uchar ascii)
 		resettitle();
 		xloadcols();
 		xsetmode(0, MODE_HIDE);
+		xsetmode(0, MODE_BRCKTPASTE);
 		break;
 	case '=': /* DECPAM -- Application keypad */
 		xsetmode(1, MODE_APPKEYPAD);
@ -2545,7 +2634,7 @@ twrite(const char *buf, int buflen, int show_ctrl)
 void
 tresize(int col, int row)
 {
-	int i;
+	int i, j;
 	int minrow = MIN(row, term.row);
 	int mincol = MIN(col, term.col);
 	int *bp;
@ -2582,6 +2671,14 @@ tresize(int col, int row)
 	term.dirty = xrealloc(term.dirty, row * sizeof(*term.dirty));
 	term.tabs = xrealloc(term.tabs, col * sizeof(*term.tabs));

+	for (i = 0; i < HISTSIZE; i++) {
+		term.hist[i] = xrealloc(term.hist[i], col * sizeof(Glyph));
+		for (j = mincol; j < col; j++) {
+			term.hist[i][j] = term.c.attr;
+			term.hist[i][j].u = ' ';
+		}
+	}
+
 	/* resize each row to new width, zero-pad if needed */
 	for (i = 0; i < minrow; i++) {
 		term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph));
@ -2640,7 +2737,7 @@ drawregion(int x1, int y1, int x2, int y2)
 			continue;

 		term.dirty[y] = 0;
-		xdrawline(term.line[y], x1, y, x2);
+		xdrawline(TLINE(y), x1, y, x2);
 	}
 }

@ -2661,8 +2758,10 @@ draw(void)
 		cx--;

 	drawregion(0, 0, term.col, term.row);
+	if (term.scr == 0)
 		xdrawcursor(cx, term.c.y, term.line[term.c.y][cx],
-			term.ocx, term.ocy, term.line[term.ocy][term.ocx]);
+				term.ocx, term.ocy, term.line[term.ocy][term.ocx],
+				term.line[term.ocy], term.col);
 	term.ocx = cx;
 	term.ocy = term.c.y;
 	xfinishdraw();
--- a/st.c.orig
+++ b/st.c.orig
--- a/st.h
+++ b/st.h
@ -11,7 +11,8 @@
 #define DIVCEIL(n, d)		(((n) + ((d) - 1)) / (d))
 #define DEFAULT(a, b)		(a) = (a) ? (a) : (b)
 #define LIMIT(x, a, b)		(x) = (x) < (a) ? (a) : (x) > (b) ? (b) : (x)
-#define ATTRCMP(a, b)		((a).mode != (b).mode || (a).fg != (b).fg || \
+#define ATTRCMP(a, b)		(((a).mode & (~ATTR_WRAP)) != ((b).mode & (~ATTR_WRAP)) || \
+				(a).fg != (b).fg || \
 				(a).bg != (b).bg)
 #define TIMEDIFF(t1, t2)	((t1.tv_sec-t2.tv_sec)*1000 + \
 				(t1.tv_nsec-t2.tv_nsec)/1E6)
@ -81,6 +82,8 @@ void die(const char *, ...);
 void redraw(void);
 void draw(void);

+void kscrolldown(const Arg *);
+void kscrollup(const Arg *);
 void printscreen(const Arg *);
 void printsel(const Arg *);
 void sendbreak(const Arg *);
--- a/st.o
+++ b/st.o
--- a/win.h
+++ b/win.h
@ -25,7 +25,7 @@ enum win_mode {

 void xbell(void);
 void xclipcopy(void);
-void xdrawcursor(int, int, Glyph, int, int, Glyph);
+void xdrawcursor(int, int, Glyph, int, int, Glyph, Line, int);
 void xdrawline(Line, int, int, int);
 void xfinishdraw(void);
 void xloadcols(void);
--- a/x.c
+++ b/x.c
@ -19,6 +19,7 @@ char *argv0;
 #include "arg.h"
 #include "st.h"
 #include "win.h"
+#include "hb.h"

 /* types used in config.h */
 typedef struct {
@ -105,6 +106,7 @@ typedef struct {
 	XSetWindowAttributes attrs;
 	int scr;
 	int isfixed; /* is fixed geometry? */
+	int depth; /* bit depth */
 	int l, t; /* left and top offset */
 	int gm; /* geometry mask */
 } XWindow;
@ -141,8 +143,9 @@ typedef struct {
 } DC;

 static inline ushort sixd_to_16bit(int);
+static void xresetfontsettings(ushort mode, Font **font, int *frcflags);
 static int xmakeglyphfontspecs(XftGlyphFontSpec *, const Glyph *, int, int, int);
-static void xdrawglyphfontspecs(const XftGlyphFontSpec *, Glyph, int, int, int);
+static void xdrawglyphfontspecs(const XftGlyphFontSpec *, Glyph, int, int, int, int);
 static void xdrawglyph(Glyph, int, int);
 static void xclear(int, int, int, int);
 static int xgeommasktogravity(int);
@ -752,12 +755,12 @@ xresize(int col, int row)

 	XFreePixmap(xw.dpy, xw.buf);
 	xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h,
-			DefaultDepth(xw.dpy, xw.scr));
+			xw.depth);
 	XftDrawChange(xw.draw, xw.buf);
 	xclear(0, 0, win.w, win.h);

 	/* resize to new width */
-	xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec));
+	xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec) * 4);
 }

 ushort
@ -812,6 +815,10 @@ xloadcols(void)
 			else
 				die("could not allocate color %d\n", i);
 		}
+
+	dc.col[defaultbg].color.alpha = (unsigned short)(0xffff * alpha);
+	dc.col[defaultbg].pixel &= 0x00FFFFFF;
+	dc.col[defaultbg].pixel |= (unsigned char)(0xff * alpha) << 24;
 	loaded = 1;
 }

@ -842,6 +849,12 @@ xsetcolorname(int x, const char *name)
 	XftColorFree(xw.dpy, xw.vis, xw.cmap, &dc.col[x]);
 	dc.col[x] = ncolor;

+	if (x == defaultbg) {
+		dc.col[defaultbg].color.alpha = (unsigned short)(0xffff * alpha);
+		dc.col[defaultbg].pixel &= 0x00FFFFFF;
+		dc.col[defaultbg].pixel |= (unsigned char)(0xff * alpha) << 24;
+	}
+
 	return 0;
 }

@ -1062,6 +1075,9 @@ xunloadfont(Font *f)
 void
 xunloadfonts(void)
 {
+	/* Clear Harfbuzz font cache. */
+	hbunloadfonts();
+
 	/* Free the loaded fonts in the font cache.  */
 	while (frclen > 0)
 		XftFontClose(xw.dpy, frc[--frclen].font);
@ -1131,14 +1147,28 @@ xinit(int cols, int rows)
 {
 	XGCValues gcvalues;
 	Cursor cursor;
-	Window parent;
+	Window parent, root;
 	pid_t thispid = getpid();
 	XColor xmousefg, xmousebg;
+	XWindowAttributes attr;
+	XVisualInfo vis;

 	if (!(xw.dpy = XOpenDisplay(NULL)))
 		die("can't open display\n");
 	xw.scr = XDefaultScreen(xw.dpy);
-	xw.vis = XDefaultVisual(xw.dpy, xw.scr);
+
+	root = XRootWindow(xw.dpy, xw.scr);
+	if (!(opt_embed && (parent = strtol(opt_embed, NULL, 0))))
+		parent = root;
+
+	if (XMatchVisualInfo(xw.dpy, xw.scr, 32, TrueColor, &vis) != 0) {
+		xw.vis = vis.visual;
+		xw.depth = vis.depth;
+	} else {
+		XGetWindowAttributes(xw.dpy, parent, &attr);
+		xw.vis = attr.visual;
+		xw.depth = attr.depth;
+	}

 	/* font */
 	if (!FcInit())
@ -1148,7 +1178,7 @@ xinit(int cols, int rows)
 	xloadfonts(usedfont, 0);

 	/* colors */
-	xw.cmap = XDefaultColormap(xw.dpy, xw.scr);
+	xw.cmap = XCreateColormap(xw.dpy, parent, xw.vis, None);
 	xloadcols();

 	/* adjust fixed window geometry */
@ -1168,24 +1198,24 @@ xinit(int cols, int rows)
 		| ButtonMotionMask | ButtonPressMask | ButtonReleaseMask;
 	xw.attrs.colormap = xw.cmap;

-	if (!(opt_embed && (parent = strtol(opt_embed, NULL, 0))))
-		parent = XRootWindow(xw.dpy, xw.scr);
 	xw.win = XCreateWindow(xw.dpy, parent, xw.l, xw.t,
-			win.w, win.h, 0, XDefaultDepth(xw.dpy, xw.scr), InputOutput,
+			win.w, win.h, 0, xw.depth, InputOutput,
 			xw.vis, CWBackPixel | CWBorderPixel | CWBitGravity
 			| CWEventMask | CWColormap, &xw.attrs);
+	if (parent != root)
+		XReparentWindow(xw.dpy, xw.win, parent, xw.l, xw.t);

 	memset(&gcvalues, 0, sizeof(gcvalues));
 	gcvalues.graphics_exposures = False;
-	dc.gc = XCreateGC(xw.dpy, parent, GCGraphicsExposures,
+	dc.gc = XCreateGC(xw.dpy, xw.win, GCGraphicsExposures,
 			&gcvalues);
 	xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h,
-			DefaultDepth(xw.dpy, xw.scr));
+			xw.depth);
 	XSetForeground(xw.dpy, dc.gc, dc.col[defaultbg].pixel);
 	XFillRectangle(xw.dpy, xw.buf, dc.gc, 0, 0, win.w, win.h);

 	/* font spec buffer */
-	xw.specbuf = xmalloc(cols * sizeof(GlyphFontSpec));
+	xw.specbuf = xmalloc(cols * sizeof(GlyphFontSpec) * 4);

 	/* Xft rendering context */
 	xw.draw = XftDrawCreate(xw.dpy, xw.buf, xw.vis, xw.cmap);
@ -1239,63 +1269,73 @@ xinit(int cols, int rows)
 		xsel.xtarget = XA_STRING;
 }

+void
+xresetfontsettings(ushort mode, Font **font, int *frcflags)
+{
+	*font = &dc.font;
+	if ((mode & ATTR_ITALIC) && (mode & ATTR_BOLD)) {
+		*font = &dc.ibfont;
+		*frcflags = FRC_ITALICBOLD;
+	} else if (mode & ATTR_ITALIC) {
+		*font = &dc.ifont;
+		*frcflags = FRC_ITALIC;
+	} else if (mode & ATTR_BOLD) {
+		*font = &dc.bfont;
+		*frcflags = FRC_BOLD;
+	}
+}
+
 int
 xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x, int y)
 {
 	float winx = borderpx + x * win.cw, winy = borderpx + y * win.ch, xp, yp;
-	ushort mode, prevmode = USHRT_MAX;
+	ushort mode = glyphs[0].mode & ~ATTR_WRAP;
 	Font *font = &dc.font;
 	int frcflags = FRC_NORMAL;
-	float runewidth = win.cw;
+	float runewidth = win.cw * ((glyphs[0].mode & ATTR_WIDE) ? 2.0f : 1.0f);
 	Rune rune;
 	FT_UInt glyphidx;
 	FcResult fcres;
 	FcPattern *fcpattern, *fontpattern;
 	FcFontSet *fcsets[] = { NULL };
 	FcCharSet *fccharset;
-	int i, f, numspecs = 0;
+	int f, code_idx, numspecs = 0;
+	float cluster_xp = xp, cluster_yp = yp;
+	HbTransformData shaped = { 0 };

-	for (i = 0, xp = winx, yp = winy + font->ascent; i < len; ++i) {
-		/* Fetch rune and mode for current glyph. */
-		rune = glyphs[i].u;
-		mode = glyphs[i].mode;
+	/* Initial values. */
+	xresetfontsettings(mode, &font, &frcflags);

-		/* Skip dummy wide-character spacing. */
-		if (mode == ATTR_WDUMMY)
+	/* Shape the segment. */
+	hbtransform(&shaped, font->match, glyphs, 0, len);
+	xp = winx; yp = winy + font->ascent;
+	cluster_xp = xp; cluster_yp = yp;
+
+	for (code_idx = 0; code_idx < shaped.count; code_idx++) {
+		int idx = shaped.glyphs[code_idx].cluster;
+
+		if (glyphs[idx].mode & ATTR_WDUMMY)
 			continue;

-		/* Determine font for glyph if different from previous glyph. */
-		if (prevmode != mode) {
-			prevmode = mode;
-			font = &dc.font;
-			frcflags = FRC_NORMAL;
-			runewidth = win.cw * ((mode & ATTR_WIDE) ? 2.0f : 1.0f);
-			if ((mode & ATTR_ITALIC) && (mode & ATTR_BOLD)) {
-				font = &dc.ibfont;
-				frcflags = FRC_ITALICBOLD;
-			} else if (mode & ATTR_ITALIC) {
-				font = &dc.ifont;
-				frcflags = FRC_ITALIC;
-			} else if (mode & ATTR_BOLD) {
-				font = &dc.bfont;
-				frcflags = FRC_BOLD;
-			}
-			yp = winy + font->ascent;
-		}
-
-		/* Lookup character index with default font. */
-		glyphidx = XftCharIndex(xw.dpy, font->match, rune);
-		if (glyphidx) {
-			specs[numspecs].font = font->match;
-			specs[numspecs].glyph = glyphidx;
-			specs[numspecs].x = (short)xp;
-			specs[numspecs].y = (short)yp;
+		/* Advance the drawing cursor if we've moved to a new cluster */
+		if (code_idx > 0 && idx != shaped.glyphs[code_idx - 1].cluster) {
 			xp += runewidth;
-			numspecs++;
-			continue;
+			cluster_xp = xp;
+			cluster_yp = yp;
 		}

-		/* Fallback on font cache, search the font cache for match. */
+		if (shaped.glyphs[code_idx].codepoint != 0) {
+			/* If symbol is found, put it into the specs. */
+			specs[numspecs].font = font->match;
+			specs[numspecs].glyph = shaped.glyphs[code_idx].codepoint;
+			specs[numspecs].x = cluster_xp + (short)(shaped.positions[code_idx].x_offset / 64.);
+			specs[numspecs].y = cluster_yp - (short)(shaped.positions[code_idx].y_offset / 64.);
+			cluster_xp += shaped.positions[code_idx].x_advance / 64.;
+			cluster_yp += shaped.positions[code_idx].y_advance / 64.;
+			numspecs++;
+		} else {
+			/* If it's not found, try to fetch it through the font cache. */
+			rune = glyphs[idx].u;
 			for (f = 0; f < frclen; f++) {
 				glyphidx = XftCharIndex(xw.dpy, frc[f].font, rune);
 				/* Everything correct. */
@ -1364,17 +1404,18 @@ xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x
 			specs[numspecs].glyph = glyphidx;
 			specs[numspecs].x = (short)xp;
 			specs[numspecs].y = (short)yp;
-		xp += runewidth;
 			numspecs++;
 		}
+	}

+	/* Cleanup and get ready for next segment. */
+	hbcleanup(&shaped);
 	return numspecs;
 }

 void
-xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, int y)
+xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, int y, int charlen)
 {
-	int charlen = len * ((base.mode & ATTR_WIDE) ? 2 : 1);
 	int winx = borderpx + x * win.cw, winy = borderpx + y * win.ch,
 	    width = charlen * win.cw;
 	Color *fg, *bg, *temp, revfg, revbg, truefg, truebg;
@ -1510,21 +1551,24 @@ void
 xdrawglyph(Glyph g, int x, int y)
 {
 	int numspecs;
-	XftGlyphFontSpec spec;
+	XftGlyphFontSpec *specs = xw.specbuf;

-	numspecs = xmakeglyphfontspecs(&spec, &g, 1, x, y);
-	xdrawglyphfontspecs(&spec, g, numspecs, x, y);
+	numspecs = xmakeglyphfontspecs(specs, &g, 1, x, y);
+	xdrawglyphfontspecs(specs, g, numspecs, x, y, (g.mode & ATTR_WIDE) ? 2 : 1);
 }

 void
-xdrawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og)
+xdrawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og, Line line, int len)
 {
 	Color drawcol;

 	/* remove the old cursor */
 	if (selected(ox, oy))
 		og.mode ^= ATTR_REVERSE;
-	xdrawglyph(og, ox, oy);
+
+	/* Redraw the line where cursor was previously.
+	 * It will restore the ligatures broken by the cursor. */
+	xdrawline(line, 0, oy, len);

 	if (IS_SET(MODE_HIDE))
 		return;
@ -1658,18 +1702,16 @@ xdrawline(Line line, int x1, int y1, int x2)
 	Glyph base, new;
 	XftGlyphFontSpec *specs = xw.specbuf;

-	numspecs = xmakeglyphfontspecs(specs, &line[x1], x2 - x1, x1, y1);
 	i = ox = 0;
-	for (x = x1; x < x2 && i < numspecs; x++) {
+	for (x = x1; x < x2; x++) {
 		new = line[x];
 		if (new.mode == ATTR_WDUMMY)
 			continue;
 		if (selected(x, y1))
 			new.mode ^= ATTR_REVERSE;
-		if (i > 0 && ATTRCMP(base, new)) {
-			xdrawglyphfontspecs(specs, base, i, ox, y1);
-			specs += i;
-			numspecs -= i;
+		if ((i > 0) && ATTRCMP(base, new)) {
+			numspecs = xmakeglyphfontspecs(specs, &line[ox], x - ox, ox, y1);
+			xdrawglyphfontspecs(specs, base, numspecs, ox, y1, x - ox);
 			i = 0;
 		}
 		if (i == 0) {
@ -1678,8 +1720,10 @@ xdrawline(Line line, int x1, int y1, int x2)
 		}
 		i++;
 	}
-	if (i > 0)
-		xdrawglyphfontspecs(specs, base, i, ox, y1);
+	if (i > 0) {
+		numspecs = xmakeglyphfontspecs(specs, &line[ox], x2 - ox, ox, y1);
+		xdrawglyphfontspecs(specs, base, numspecs, ox, y1, x2 - ox);
+	}
 }

 void
@ -2044,6 +2088,10 @@ main(int argc, char *argv[])
 	case 'a':
 		allowaltscreen = 0;
 		break;
+	case 'A':
+		alpha = strtof(EARGF(usage()), NULL);
+		LIMIT(alpha, 0.0, 1.0);
+		break;
 	case 'c':
 		opt_class = EARGF(usage());
 		break;
--- a/x.c.orig
+++ b/x.c.orig
--- a/x.o
+++ b/x.o
Author	SHA1	Message	Date
lucy	3266e89eb4	add patches	2026-02-26 11:54:02 +01:00
Milos Nikic	688f70add0	st: guard tsetdirt() against zero-sized terminal tsetdirt() assumes term.row > 0. During early init or resize paths this may not hold, leading to out-of-bounds access. Bail out early if there are no rows.	2026-01-16 14:12:07 +01:00
Roberto E. Vargas Caballero	0723b7e39e	Disable bracked paste in reset Sadly, there are too many programs today that enable this mode and it is becoming very common to find the terminal adding characters before and after in every of your pastes. A reset should disable this mode.	2025-12-02 20:09:47 +01:00
Hiltjo Posthuma	6e97047474	bump version to 0.9.3	2025-08-09 14:35:14 +02:00
Hiltjo Posthuma	5a4666c19e	add a few comments	2025-08-09 14:22:28 +02:00
Ayman Bagabas	d6c431859c	Support OSC 110, 111, and 112 for resetting colors This adds support for OSC 110, 111, and 112 escape sequences to reset the foreground, background, and cursor colors in the terminal. The changes include handling these sequences in the `strhandle` function of `st.c`, allowing applications to reset colors to their default values. The OSC sequences originated from Xterm control sequences and are now widely used in terminal applications and supported by many terminal emulators. For applications, this allows them to reset colors to default values without needing to know the colors beforehand. Signed-off-by: Ayman Bagabas <ayman.bagabas@gmail.com>	2025-08-09 12:34:01 +02:00
sasha	f114bcedd1	Eat up "CSI 58" sequences This is used in the wild by systemd systemctl for example and st misinterpreted it as "blink", because it didn't know "58", then saw "5" as "blink", and then didn't know "245". This should print "foo" as normal text: printf '\e[58:5:245mfoo\n' printf '\e[58:2:50💯200mfoo\n'	2025-07-27 20:06:54 +02:00
Johannes Altmanninger	98610fcd37	Do not interpret CSI ? u as DECRC The kitty keyboard protocol docs recommend CSI ? u to query support for that protocol, see https://sw.kovidgoyal.net/kitty/keyboard-protocol/ For better or worse, fish shell uses this query to work around bugs in other terminals triggered by requesting that protocol via CSI = 5 u. Unfortunately, st interprets CSI ? u as DECRC (restore cursor position). reproduce with 'printf "\x1b[?u"; cat'. fish could work around this by switching to the alternate screen before running this query; but that might cause tearing on terminals that don't support Synchronized Output. I'm not sure. In the meantime, let's correct our parser. This adds a redundant else-after-return, for consistency with the surrounding code.	2025-01-30 17:50:37 +01:00
Markus Rinne	6009e6e25b	Clear screen: Fix edge case With sequence \e[1J, if cursor is on second line, clear the first line.	2024-12-06 13:42:50 +01:00
Lucas de Sena	a0274bc20e	fix BadMatch error when embedding on some windows When embedded, st fails with BadMatch error if the embedder's window has non-default colormap/depth/visual. This commit fixes that by creating st's window inside root and then reparent it into embedder. The reference window for dc.gc is also changed to match root's visuals. A similar commit had been made for dmenu[1]. See this issue[2] on github for context. [1]: https://git.suckless.org/dmenu/commit/0fe460dbd469a1d5b6a7140d0e1801935e4a923b.html [2]: https://github.com/phillbush/xfiles/issues/47	2024-08-09 13:34:56 +02:00