add everforest hard themes

This patch adds a ring buffer for scrollback to the terminal.  The
advantage of using a ring buffer is that the common case, scrolling with
no static screen content, can be achieved very efficiently by
incrementing and decrementing the starting line (modulo buffer size).

The scrollback buffer is limited to HISTSIZE lines in order to bound
memory usage. As the lines are allocated on demand, it is possible to
implement unlimited scrollback with few changes.  If the terminal is
reset, the scroll back buffer is reset, too.

(apply st-scrollback-ringbuffer-0.8.5.diff on top of colorscheme)

config.def.h

@@ -5,7 +5,7 @@
  *
  * font: see http://freedesktop.org/software/fontconfig/fontconfig-user.html
  */
-static char *font = "Liberation Mono:pixelsize=12:antialias=true:autohint=true";
+static char *font = "FiraCode Nerd Font Ret:size=10";
 static int borderpx = 2;
 
 /*
@@ -93,46 +93,94 @@ char *termname = "st-256color";
  */
 unsigned int tabspaces = 8;
 
-/* Terminal colors (16 first used in escape sequence) */
+typedef struct {
-static const char *colorname[] = {
+	const char* const colors[260]; /* terminal colors */
-	/* 8 normal colors */
+	unsigned int fg;               /* foreground */
-	"black",
+	unsigned int bg;               /* background */
-	"red3",
+	unsigned int cs;               /* cursor */
-	"green3",
+	unsigned int rcs;              /* reverse cursor */
-	"yellow3",
+} ColorScheme;
-	"blue2",
+/*
-	"magenta3",
+ * Terminal colors (16 first used in escape sequence,
-	"cyan3",
+ * 2 last for custom cursor color),
-	"gray90",
+ * foreground, background, cursor, reverse cursor
+ */
+static const ColorScheme schemes[] = {
+	// everforest-dark-hard
+	{{ "#414b50", "#e67e80", "#a7c080", "#dbbc7f",
+	   "#7fbbb3", "#d699b6", "#83c092", "#d3c6aa",
+	   "#475258", "#e67e80", "#a7c080", "#dbbc7f",
+	   "#7fbbb3", "#d699b6", "#83c092", "#d3c6aa",
+	   [256] = "#a7c080", "#555555", "#d3c6aa", "#272e33"}, 258, 259, 256, 257},
 
-	/* 8 bright colors */
+	// everforest-light-hard
-	"gray50",
+	{{ "#5c6a72", "#f85552", "#8da101", "#dfa000",
-	"red",
+	   "#3a94c5", "#df69ba", "#35a77c", "#e8e5d5",
-	"green",
+	   "#5c6a72", "#f85552", "#8da101", "#dfa000",
-	"yellow",
+	   "#3a94c5", "#df69ba", "#35a77c", "#e8e5d5",
-	"#5c5cff",
+	   [256] = "#35a77c", "#555555", "#5c6a72", "#fffbef"}, 258, 259, 256, 257},
-	"magenta",
-	"cyan",
-	"white",
 
-	[255] = 0,
+	// tokyonight-storm
+	{{"#1d202f", "#f7768e", "#9ece6a", "#e0af68",
+	  "#7aa2f7", "#bb9af7", "#7dcfff", "#a9b1d6",
+	  "#414868", "#f7768e", "#9ece6a", "#e0af68",
+	  "#7aa2f7", "#bb9af7", "#7dcfff", "#c0caf5",
+	  [256]="#81A1C1", "#555555", "#c0caf5", "#24283b"}, 258, 259, 256, 257},
 
-	/* more colors can be added after 255 to use with DefaultXX */
+	// tokyonight-day
-	"#cccccc",
+	{{"#e9e9ed", "#f52a65", "#587539", "#8c6c3e",
-	"#555555",
+	  "#2e7de9", "#9854f1", "#007197", "#6172b0",
-	"gray90", /* default foreground colour */
+	  "#a1a6c5", "#f52a65", "#587539", "#8c6c3e",
-	"black", /* default background colour */
+	  "#2e7de9", "#9854f1", "#007197", "#3760bf",
+	  [256]="#3879C5", "#555555", "#3760bf", "#e1e2e7"}, 258, 259, 256, 257},
+
+	// One Half dark
+	{{"#282c34", "#e06c75", "#98c379", "#e5c07b",
+	  "#61afef", "#c678dd", "#56b6c2", "#dcdfe4",
+	  "#282c34", "#e06c75", "#98c379", "#e5c07b",
+	  "#61afef", "#c678dd", "#56b6c2", "#dcdfe4",
+	  [256]="#cccccc", "#555555", "black", "black"}, 7, 0, 256, 257},
+
+	// One Half light
+	{{"#fafafa", "#e45649", "#50a14f", "#c18401",
+      "#0184bc", "#a626a4", "#0997b3", "#383a42",
+	  "#fafafa", "#e45649", "#50a14f", "#c18401",
+	  "#0184bc", "#a626a4", "#0997b3", "#383a42",
+	  [256]="#cccccc", "#555555", "black", "black"}, 7, 0, 256, 257},
+
+	// Solarized dark
+	{{"#073642", "#dc322f", "#859900", "#b58900",
+	  "#268bd2", "#d33682", "#2aa198", "#eee8d5",
+	  "#002b36", "#cb4b16", "#586e75", "#657b83",
+	  "#839496", "#6c71c4", "#93a1a1", "#fdf6e3",
+	  [256]="#93a1a1", "#fdf6e3", "black", "black"}, 12, 8, 256, 257},
+
+	// Solarized light
+	{{"#eee8d5", "#dc322f", "#859900", "#b58900",
+	  "#268bd2", "#d33682", "#2aa198", "#073642",
+	  "#fdf6e3", "#cb4b16", "#93a1a1", "#839496",
+	  "#657b83", "#6c71c4", "#586e75", "#002b36",
+	  [256]="#586e75", "#002b36", "black", "black"}, 12, 8, 256, 257},
+
+	// st (dark)
+	{{"black", "red3", "green3", "yellow3",
+	  "blue2", "magenta3", "cyan3", "gray90",
+	  "gray50", "red", "green", "yellow",
+	  "#5c5cff", "magenta", "cyan", "white",
+	  [256]="#cccccc", "#555555", "black", "black"}, 7, 0, 256, 257},
 };
 
+static const char * const * colorname;
+int colorscheme = 0;
 
 /*
  * Default colors (colorname index)
  * foreground, background, cursor, reverse cursor
  */
-unsigned int defaultfg = 258;
+unsigned int defaultfg;
-unsigned int defaultbg = 259;
+unsigned int defaultbg;
-unsigned int defaultcs = 256;
+unsigned int defaultcs;
-static unsigned int defaultrcs = 257;
+static unsigned int defaultrcs;
 
 /*
  * Default shape of cursor
@@ -201,6 +249,19 @@ static Shortcut shortcuts[] = {
 	{ TERMMOD,              XK_Y,           selpaste,       {.i =  0} },
 	{ ShiftMask,            XK_Insert,      selpaste,       {.i =  0} },
 	{ TERMMOD,              XK_Num_Lock,    numlock,        {.i =  0} },
+	{ MODKEY,               XK_F1,          selectscheme,   {.i =  0} },
+	{ MODKEY,               XK_F2,          selectscheme,   {.i =  1} },
+	{ MODKEY,               XK_F3,          selectscheme,   {.i =  2} },
+	{ MODKEY,               XK_F4,          selectscheme,   {.i =  3} },
+	{ MODKEY,               XK_F5,          selectscheme,   {.i =  4} },
+	{ MODKEY,               XK_F6,          selectscheme,   {.i =  5} },
+	{ MODKEY,               XK_F7,          selectscheme,   {.i =  6} },
+	{ MODKEY,               XK_F8,          selectscheme,   {.i =  7} },
+	{ MODKEY,               XK_F9,          selectscheme,   {.i =  8} },
+	{ MODKEY,               XK_F10,         nextscheme,     {.i = +1} },
+	{ MODKEY|ControlMask,   XK_F10,         nextscheme,     {.i = -1} },
+	{ ShiftMask,            XK_Page_Up,     kscrollup,      {.i = -1} },
+	{ ShiftMask,            XK_Page_Down,   kscrolldown,    {.i = -1} },
 };
 
 /*

st.c

@@ -43,6 +43,10 @@
 #define ISCONTROL(c)		(ISCONTROLC0(c) || ISCONTROLC1(c))
 #define ISDELIM(u)		(u && wcschr(worddelimiters, u))
 
+#define TSCREEN term.screen[IS_SET(MODE_ALTSCREEN)]
+#define TLINEOFFSET(y) (((y) + TSCREEN.cur - TSCREEN.off + TSCREEN.size) % TSCREEN.size)
+#define TLINE(y) (TSCREEN.buffer[TLINEOFFSET(y)])
+
 enum term_mode {
 	MODE_WRAP        = 1 << 0,
 	MODE_INSERT      = 1 << 1,
@@ -109,12 +113,21 @@ typedef struct {
 	int alt;
 } Selection;
 
+/* Screen lines */
+typedef struct {
+	Line* buffer;  /* ring buffer */
+	int size;      /* size of buffer */
+	int cur;       /* start of active screen */
+	int off;       /* scrollback line offset */
+	TCursor sc;    /* saved cursor */
+} LineBuffer;
+
 /* Internal representation of the screen */
 typedef struct {
 	int row;      /* nb row */
 	int col;      /* nb col */
-	Line *line;   /* screen */
+	LineBuffer screen[2]; /* screen and alternate screen */
-	Line *alt;    /* alternate screen */
+	int linelen;  /* allocated line length */
 	int *dirty;   /* dirtyness of lines */
 	TCursor c;    /* cursor */
 	int ocx;      /* old cursor col */
@@ -203,6 +216,8 @@ static void tdeftran(char);
 static void tstrsequence(uchar);
 
 static void drawregion(int, int, int, int);
+static void clearline(Line, Glyph, int, int);
+static Line ensureline(Line);
 
 static void selnormalize(void);
 static void selscroll(int, int);
@@ -408,11 +423,12 @@ int
 tlinelen(int y)
 {
 	int i = term.col;
+	Line line = TLINE(y);
 
-	if (term.line[y][i - 1].mode & ATTR_WRAP)
+	if (line[i - 1].mode & ATTR_WRAP)
 		return i;
 
-	while (i > 0 && term.line[y][i - 1].u == ' ')
+	while (i > 0 && line[i - 1].u == ' ')
 		--i;
 
 	return i;
@@ -521,7 +537,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 +552,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 +580,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 +618,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;
 
@@ -949,12 +965,15 @@ int
 tattrset(int attr)
 {
 	int i, j;
+	int y = TLINEOFFSET(0);
 
 	for (i = 0; i < term.row-1; i++) {
+		Line line = TSCREEN.buffer[y];
 		for (j = 0; j < term.col-1; j++) {
-			if (term.line[i][j].mode & attr)
+			if (line[j].mode & attr)
 				return 1;
 		}
+		y = (y+1) % TSCREEN.size;
 	}
 
 	return 0;
@@ -976,14 +995,17 @@ void
 tsetdirtattr(int attr)
 {
 	int i, j;
+	int y = TLINEOFFSET(0);
 
 	for (i = 0; i < term.row-1; i++) {
+		Line line = TSCREEN.buffer[y];
 		for (j = 0; j < term.col-1; j++) {
-			if (term.line[i][j].mode & attr) {
+			if (line[j].mode & attr) {
 				tsetdirt(i, i);
 				break;
 			}
 		}
+		y = (y+1) % TSCREEN.size;
 	}
 }
 
@@ -996,27 +1018,19 @@ tfulldirt(void)
 void
 tcursor(int mode)
 {
-	static TCursor c[2];
-	int alt = IS_SET(MODE_ALTSCREEN);
-
 	if (mode == CURSOR_SAVE) {
-		c[alt] = term.c;
+		TSCREEN.sc = term.c;
 	} else if (mode == CURSOR_LOAD) {
-		term.c = c[alt];
+		term.c = TSCREEN.sc;
-		tmoveto(c[alt].x, c[alt].y);
+		tmoveto(term.c.x, term.c.y);
 	}
 }
 
 void
 treset(void)
 {
-	uint i;
+	int i, j;
-
+	Glyph g = (Glyph){ .fg = defaultfg, .bg = defaultbg};
-	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)
@@ -1028,17 +1042,37 @@ treset(void)
 	term.charset = 0;
 
 	for (i = 0; i < 2; i++) {
-		tmoveto(0, 0);
+		term.screen[i].sc = (TCursor){{
-		tcursor(CURSOR_SAVE);
+			.fg = defaultfg,
-		tclearregion(0, 0, term.col-1, term.row-1);
+			.bg = defaultbg
-		tswapscreen();
+		}};
+		term.screen[i].cur = 0;
+		term.screen[i].off = 0;
+		for (j = 0; j < term.row; ++j) {
+			if (term.col != term.linelen)
+				term.screen[i].buffer[j] = xrealloc(term.screen[i].buffer[j], term.col * sizeof(Glyph));
+			clearline(term.screen[i].buffer[j], g, 0, term.col);
+		}
+		for (j = term.row; j < term.screen[i].size; ++j) {
+			free(term.screen[i].buffer[j]);
+			term.screen[i].buffer[j] = NULL;
+		}
 	}
+	tcursor(CURSOR_LOAD);
+	term.linelen = term.col;
+	tfulldirt();
 }
 
 void
 tnew(int col, int row)
 {
-	term = (Term){ .c = { .attr = { .fg = defaultfg, .bg = defaultbg } } };
+	int i;
+	term = (Term){};
+	term.screen[0].buffer = xmalloc(HISTSIZE * sizeof(Line));
+	term.screen[0].size = HISTSIZE;
+	term.screen[1].buffer = NULL;
+	for (i = 0; i < HISTSIZE; ++i) term.screen[0].buffer[i] = NULL;
+
 	tresize(col, row);
 	treset();
 }
@@ -1046,14 +1080,42 @@ tnew(int col, int row)
 void
 tswapscreen(void)
 {
-	Line *tmp = term.line;
-
-	term.line = term.alt;
-	term.alt = tmp;
 	term.mode ^= MODE_ALTSCREEN;
 	tfulldirt();
 }
 
+void
+kscrollup(const Arg *a)
+{
+	int n = a->i;
+
+	if (IS_SET(MODE_ALTSCREEN))
+		return;
+
+	if (n < 0) n = (-n) * term.row;
+	if (n > TSCREEN.size - term.row - TSCREEN.off) n = TSCREEN.size - term.row - TSCREEN.off;
+	while (!TLINE(-n)) --n;
+	TSCREEN.off += n;
+	selscroll(0, n);
+	tfulldirt();
+}
+
+void
+kscrolldown(const Arg *a)
+{
+
+	int n = a->i;
+
+	if (IS_SET(MODE_ALTSCREEN))
+		return;
+
+	if (n < 0) n = (-n) * term.row;
+	if (n > TSCREEN.off) n = TSCREEN.off;
+	TSCREEN.off -= n;
+	selscroll(0, -n);
+	tfulldirt();
+}
+
 void
 tscrolldown(int orig, int n)
 {
@@ -1062,15 +1124,29 @@ tscrolldown(int orig, int n)
 
 	LIMIT(n, 0, term.bot-orig+1);
 
-	tsetdirt(orig, term.bot-n);
+	/* Ensure that lines are allocated */
-	tclearregion(0, term.bot-n+1, term.col-1, term.bot);
+	for (i = -n; i < 0; i++) {
-
+		TLINE(i) = ensureline(TLINE(i));
-	for (i = term.bot; i >= orig+n; i--) {
-		temp = term.line[i];
-		term.line[i] = term.line[i-n];
-		term.line[i-n] = temp;
 	}
 
+	/* Shift non-scrolling areas in ring buffer */
+	for (i = term.bot+1; i < term.row; i++) {
+		temp = TLINE(i);
+		TLINE(i) = TLINE(i-n);
+		TLINE(i-n) = temp;
+	}
+	for (i = 0; i < orig; i++) {
+		temp = TLINE(i);
+		TLINE(i) = TLINE(i-n);
+		TLINE(i-n) = temp;
+	}
+
+	/* Scroll buffer */
+	TSCREEN.cur = (TSCREEN.cur + TSCREEN.size - n) % TSCREEN.size;
+	/* Clear lines that have entered the view */
+	tclearregion(0, orig, term.linelen-1, orig+n-1);
+	/* Redraw portion of the screen that has scrolled */
+	tsetdirt(orig+n-1, term.bot);
 	selscroll(orig, n);
 }
 
@@ -1082,15 +1158,29 @@ tscrollup(int orig, int n)
 
 	LIMIT(n, 0, term.bot-orig+1);
 
-	tclearregion(0, orig, term.col-1, orig+n-1);
+	/* Ensure that lines are allocated */
-	tsetdirt(orig+n, term.bot);
+	for (i = term.row; i < term.row + n; i++) {
-
+		TLINE(i) = ensureline(TLINE(i));
-	for (i = orig; i <= term.bot-n; i++) {
-		temp = term.line[i];
-		term.line[i] = term.line[i+n];
-		term.line[i+n] = temp;
 	}
 
+	/* Shift non-scrolling areas in ring buffer */
+	for (i = orig-1; i >= 0; i--) {
+		temp = TLINE(i);
+		TLINE(i) = TLINE(i+n);
+		TLINE(i+n) = temp;
+	}
+	for (i = term.row-1; i >term.bot; i--) {
+		temp = TLINE(i);
+		TLINE(i) = TLINE(i+n);
+		TLINE(i+n) = temp;
+	}
+
+	/* Scroll buffer */
+	TSCREEN.cur = (TSCREEN.cur + n) % TSCREEN.size;
+	/* Clear lines that have entered the view */
+	tclearregion(0, term.bot-n+1, term.linelen-1, term.bot);
+	/* Redraw portion of the screen that has scrolled */
+	tsetdirt(orig, term.bot-n+1);
 	selscroll(orig, -n);
 }
 
@@ -1194,6 +1284,7 @@ tsetchar(Rune u, const Glyph *attr, int x, int y)
 		"⎻", "─", "⎼", "⎽", "├", "┤", "┴", "┬", /* p - w */
 		"│", "≤", "≥", "π", "≠", "£", "·", /* x - ~ */
 	};
+	Line line = TLINE(y);
 
 	/*
 	 * The table is proudly stolen from rxvt.
@@ -1202,25 +1293,25 @@ tsetchar(Rune u, const Glyph *attr, int x, int y)
 	   BETWEEN(u, 0x41, 0x7e) && vt100_0[u - 0x41])
 		utf8decode(vt100_0[u - 0x41], &u, UTF_SIZ);
 
-	if (term.line[y][x].mode & ATTR_WIDE) {
+	if (line[x].mode & ATTR_WIDE) {
 		if (x+1 < term.col) {
-			term.line[y][x+1].u = ' ';
+			line[x+1].u = ' ';
-			term.line[y][x+1].mode &= ~ATTR_WDUMMY;
+			line[x+1].mode &= ~ATTR_WDUMMY;
 		}
-	} else if (term.line[y][x].mode & ATTR_WDUMMY) {
+	} else if (line[x].mode & ATTR_WDUMMY) {
-		term.line[y][x-1].u = ' ';
+		line[x-1].u = ' ';
-		term.line[y][x-1].mode &= ~ATTR_WIDE;
+		line[x-1].mode &= ~ATTR_WIDE;
 	}
 
 	term.dirty[y] = 1;
-	term.line[y][x] = *attr;
+	line[x] = *attr;
-	term.line[y][x].u = u;
+	line[x].u = u;
 }
 
 void
 tclearregion(int x1, int y1, int x2, int y2)
 {
-	int x, y, temp;
+	int x, y, L, S, temp;
 	Glyph *gp;
 
 	if (x1 > x2)
@@ -1228,15 +1319,16 @@ tclearregion(int x1, int y1, int x2, int y2)
 	if (y1 > y2)
 		temp = y1, y1 = y2, y2 = temp;
 
-	LIMIT(x1, 0, term.col-1);
+	LIMIT(x1, 0, term.linelen-1);
-	LIMIT(x2, 0, term.col-1);
+	LIMIT(x2, 0, term.linelen-1);
 	LIMIT(y1, 0, term.row-1);
 	LIMIT(y2, 0, term.row-1);
 
+	L = TLINEOFFSET(y1);
 	for (y = y1; y <= y2; y++) {
 		term.dirty[y] = 1;
 		for (x = x1; x <= x2; x++) {
-			gp = &term.line[y][x];
+			gp = &TSCREEN.buffer[L][x];
 			if (selected(x, y))
 				selclear();
 			gp->fg = term.c.attr.fg;
@@ -1244,6 +1336,7 @@ tclearregion(int x1, int y1, int x2, int y2)
 			gp->mode = 0;
 			gp->u = ' ';
 		}
+		L = (L + 1) % TSCREEN.size;
 	}
 }
 
@@ -1258,7 +1351,7 @@ tdeletechar(int n)
 	dst = term.c.x;
 	src = term.c.x + n;
 	size = term.col - src;
-	line = term.line[term.c.y];
+	line = TLINE(term.c.y);
 
 	memmove(&line[dst], &line[src], size * sizeof(Glyph));
 	tclearregion(term.col-n, term.c.y, term.col-1, term.c.y);
@@ -1275,7 +1368,7 @@ tinsertblank(int n)
 	dst = term.c.x + n;
 	src = term.c.x;
 	size = term.col - dst;
-	line = term.line[term.c.y];
+	line = TLINE(term.c.y);
 
 	memmove(&line[dst], &line[src], size * sizeof(Glyph));
 	tclearregion(src, term.c.y, dst - 1, term.c.y);
@@ -2078,7 +2171,7 @@ tdumpline(int n)
 	char buf[UTF_SIZ];
 	const Glyph *bp, *end;
 
-	bp = &term.line[n][0];
+	bp = &TLINE(n)[0];
 	end = &bp[MIN(tlinelen(n), term.col) - 1];
 	if (bp != end || bp->u != ' ') {
 		for ( ; bp <= end; ++bp)
@@ -2171,6 +2264,28 @@ tstrsequence(uchar c)
 	term.esc |= ESC_STR;
 }
 
+void
+tupdatebgcolor(int oldbg, int newbg)
+{
+	for (int y = 0; y < term.row; y++) {
+		for (int x = 0; x < term.col; x++) {
+			if (TLINE(y)[x].bg == oldbg)
+				TLINE(y)[x].bg = newbg;
+		}
+	}
+}
+
+void
+tupdatefgcolor(int oldfg, int newfg)
+{
+	for (int y = 0; y < term.row; y++) {
+		for (int x = 0; x < term.col; x++) {
+			if (TLINE(y)[x].fg == oldfg)
+				TLINE(y)[x].fg = newfg;
+		}
+	}
+}
+
 void
 tcontrolcode(uchar ascii)
 {
@@ -2464,11 +2579,11 @@ check_control_code:
 	if (selected(term.c.x, term.c.y))
 		selclear();
 
-	gp = &term.line[term.c.y][term.c.x];
+	gp = &TLINE(term.c.y)[term.c.x];
 	if (IS_SET(MODE_WRAP) && (term.c.state & CURSOR_WRAPNEXT)) {
 		gp->mode |= ATTR_WRAP;
 		tnewline(1);
-		gp = &term.line[term.c.y][term.c.x];
+		gp = &TLINE(term.c.y)[term.c.x];
 	}
 
 	if (IS_SET(MODE_INSERT) && term.c.x+width < term.col) {
@@ -2478,7 +2593,7 @@ check_control_code:
 
 	if (term.c.x+width > term.col) {
 		tnewline(1);
-		gp = &term.line[term.c.y][term.c.x];
+		gp = &TLINE(term.c.y)[term.c.x];
 	}
 
 	tsetchar(u, &term.c.attr, term.c.x, term.c.y);
@@ -2509,6 +2624,11 @@ twrite(const char *buf, int buflen, int show_ctrl)
 	Rune u;
 	int n;
 
+	if (TSCREEN.off) {
+		TSCREEN.off = 0;
+		tfulldirt();
+	}
+
 	for (n = 0; n < buflen; n += charsize) {
 		if (IS_SET(MODE_UTF8)) {
 			/* process a complete utf8 char */
@@ -2535,56 +2655,85 @@ twrite(const char *buf, int buflen, int show_ctrl)
 }
 
 void
-tresize(int col, int row)
+clearline(Line line, Glyph g, int x, int xend)
 {
 	int i;
+	g.mode = 0;
+	g.u = ' ';
+	for (i = x; i < xend; ++i) {
+		line[i] = g;
+	}
+}
+
+Line
+ensureline(Line line)
+{
+	if (!line) {
+		line = xmalloc(term.linelen * sizeof(Glyph));
+	}
+	return line;
+}
+
+void
+tresize(int col, int row)
+{
+	int i, j;
 	int minrow = MIN(row, term.row);
 	int mincol = MIN(col, term.col);
+	int linelen = MAX(col, term.linelen);
 	int *bp;
-	TCursor c;
 
-	if (col < 1 || row < 1) {
+	if (col < 1 || row < 1 || row > HISTSIZE) {
 		fprintf(stderr,
 		        "tresize: error resizing to %dx%d\n", col, row);
 		return;
 	}
 
-	/*
+	/* Shift buffer to keep the cursor where we expect it */
-	 * slide screen to keep cursor where we expect it -
+	if (row <= term.c.y) {
-	 * tscrollup would work here, but we can optimize to
+		term.screen[0].cur = (term.screen[0].cur - row + term.c.y + 1) % term.screen[0].size;
-	 * memmove because we're freeing the earlier lines
-	 */
-	for (i = 0; i <= term.c.y - row; i++) {
-		free(term.line[i]);
-		free(term.alt[i]);
 	}
-	/* ensure that both src and dst are not NULL */
+
-	if (i > 0) {
+	/* Resize and clear line buffers as needed */
-		memmove(term.line, term.line + i, row * sizeof(Line));
+	if (linelen > term.linelen) {
-		memmove(term.alt, term.alt + i, row * sizeof(Line));
+		for (i = 0; i < term.screen[0].size; ++i) {
+			if (term.screen[0].buffer[i]) {
+				term.screen[0].buffer[i] = xrealloc(term.screen[0].buffer[i], linelen * sizeof(Glyph));
+				clearline(term.screen[0].buffer[i], term.c.attr, term.linelen, linelen);
+			}
+		}
+		for (i = 0; i < minrow; ++i) {
+			term.screen[1].buffer[i] = xrealloc(term.screen[1].buffer[i], linelen * sizeof(Glyph));
+			clearline(term.screen[1].buffer[i], term.c.attr, term.linelen, linelen);
+		}
 	}
-	for (i += row; i < term.row; i++) {
+	/* Allocate all visible lines for regular line buffer */
-		free(term.line[i]);
+	for (j = term.screen[0].cur, i = 0; i < row; ++i, j = (j + 1) % term.screen[0].size)
-		free(term.alt[i]);
+	{
+		if (!term.screen[0].buffer[j]) {
+			term.screen[0].buffer[j] = xmalloc(linelen * sizeof(Glyph));
+		}
+		if (i >= term.row) {
+			clearline(term.screen[0].buffer[j], term.c.attr, 0, linelen);
+		}
+	}
+	/* Resize alt screen */
+	term.screen[1].cur = 0;
+	term.screen[1].size = row;
+	for (i = row; i < term.row; ++i) {
+		free(term.screen[1].buffer[i]);
+	}
+	term.screen[1].buffer = xrealloc(term.screen[1].buffer, row * sizeof(Line));
+	for (i = term.row; i < row; ++i) {
+		term.screen[1].buffer[i] = xmalloc(linelen * sizeof(Glyph));
+		clearline(term.screen[1].buffer[i], term.c.attr, 0, linelen);
 	}
 
 	/* 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 */
+	/* fix tabstops */
-	for (i = 0; i < minrow; i++) {
-		term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph));
-		term.alt[i]  = xrealloc(term.alt[i],  col * sizeof(Glyph));
-	}
-
-	/* allocate any new rows */
-	for (/* i = minrow */; i < row; i++) {
-		term.line[i] = xmalloc(col * sizeof(Glyph));
-		term.alt[i] = xmalloc(col * sizeof(Glyph));
-	}
 	if (col > term.col) {
 		bp = term.tabs + term.col;
 
@@ -2594,26 +2743,16 @@ tresize(int col, int row)
 		for (bp += tabspaces; bp < term.tabs + col; bp += tabspaces)
 			*bp = 1;
 	}
+
 	/* update terminal size */
 	term.col = col;
 	term.row = row;
+	term.linelen = linelen;
 	/* reset scrolling region */
 	tsetscroll(0, row-1);
 	/* make use of the LIMIT in tmoveto */
 	tmoveto(term.c.x, term.c.y);
-	/* Clearing both screens (it makes dirty all lines) */
+	tfulldirt();
-	c = term.c;
-	for (i = 0; i < 2; i++) {
-		if (mincol < col && 0 < minrow) {
-			tclearregion(mincol, 0, col - 1, minrow - 1);
-		}
-		if (0 < col && minrow < row) {
-			tclearregion(0, minrow, col - 1, row - 1);
-		}
-		tswapscreen();
-		tcursor(CURSOR_LOAD);
-	}
-	term.c = c;
 }
 
 void
@@ -2625,14 +2764,15 @@ resettitle(void)
 void
 drawregion(int x1, int y1, int x2, int y2)
 {
-	int y;
+	int y, L;
 
+	L = TLINEOFFSET(y1);
 	for (y = y1; y < y2; y++) {
-		if (!term.dirty[y])
+		if (term.dirty[y]) {
-			continue;
+			term.dirty[y] = 0;
-
+			xdrawline(TSCREEN.buffer[L], x1, y, x2);
-		term.dirty[y] = 0;
+		}
-		xdrawline(term.line[y], x1, y, x2);
+		L = (L + 1) % TSCREEN.size;
 	}
 }
 
@@ -2647,14 +2787,15 @@ draw(void)
 	/* adjust cursor position */
 	LIMIT(term.ocx, 0, term.col-1);
 	LIMIT(term.ocy, 0, term.row-1);
-	if (term.line[term.ocy][term.ocx].mode & ATTR_WDUMMY)
+	if (TLINE(term.ocy)[term.ocx].mode & ATTR_WDUMMY)
 		term.ocx--;
-	if (term.line[term.c.y][cx].mode & ATTR_WDUMMY)
+	if (TLINE(term.c.y)[cx].mode & ATTR_WDUMMY)
 		cx--;
 
 	drawregion(0, 0, term.col, term.row);
-	xdrawcursor(cx, term.c.y, term.line[term.c.y][cx],
+	if (TSCREEN.off == 0)
-			term.ocx, term.ocy, term.line[term.ocy][term.ocx]);
+		xdrawcursor(cx, term.c.y, TLINE(term.c.y)[cx],
+				term.ocx, term.ocy, TLINE(term.ocy)[term.ocx]);
 	term.ocx = cx;
 	term.ocy = term.c.y;
 	xfinishdraw();

st.h

@@ -19,6 +19,7 @@
 
 #define TRUECOLOR(r,g,b)	(1 << 24 | (r) << 16 | (g) << 8 | (b))
 #define IS_TRUECOL(x)		(1 << 24 & (x))
+#define HISTSIZE            2000
 
 enum glyph_attribute {
 	ATTR_NULL       = 0,
@@ -36,6 +37,12 @@ enum glyph_attribute {
 	ATTR_BOLD_FAINT = ATTR_BOLD | ATTR_FAINT,
 };
 
+enum drawing_mode {
+    DRAW_NONE = 0,
+    DRAW_BG = 1 << 0,
+    DRAW_FG = 1 << 1,
+};
+
 enum selection_mode {
 	SEL_IDLE = 0,
 	SEL_EMPTY = 1,
@@ -90,6 +97,8 @@ int tattrset(int);
 void tnew(int, int);
 void tresize(int, int);
 void tsetdirtattr(int);
+void tupdatebgcolor(int, int);
+void tupdatefgcolor(int, int);
 void ttyhangup(void);
 int ttynew(const char *, char *, const char *, char **);
 size_t ttyread(void);

x.c

@@ -59,6 +59,10 @@ static void zoom(const Arg *);
 static void zoomabs(const Arg *);
 static void zoomreset(const Arg *);
 static void ttysend(const Arg *);
+static void nextscheme(const Arg *);
+static void selectscheme(const Arg *);
+void kscrollup(const Arg *);
+void kscrolldown(const Arg *);
 
 /* config.h for applying patches and the configuration. */
 #include "config.h"
@@ -142,7 +146,7 @@ typedef struct {
 
 static inline ushort sixd_to_16bit(int);
 static int xmakeglyphfontspecs(XftGlyphFontSpec *, const Glyph *, int, int, int);
-static void xdrawglyphfontspecs(const XftGlyphFontSpec *, Glyph, int, int, int);
+static void 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);
@@ -185,6 +189,7 @@ static void mousesel(XEvent *, int);
 static void mousereport(XEvent *);
 static char *kmap(KeySym, uint);
 static int match(uint, uint);
+static void updatescheme(void);
 
 static void run(void);
 static void usage(void);
@@ -801,7 +806,7 @@ xloadcols(void)
 		for (cp = dc.col; cp < &dc.col[dc.collen]; ++cp)
 			XftColorFree(xw.dpy, xw.vis, xw.cmap, cp);
 	} else {
-		dc.collen = MAX(LEN(colorname), 256);
+		dc.collen = 260;
 		dc.col = xmalloc(dc.collen * sizeof(Color));
 	}
 
@@ -1372,7 +1377,7 @@ xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x
 }
 
 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 dmode)
 {
 	int charlen = len * ((base.mode & ATTR_WIDE) ? 2 : 1);
 	int winx = borderpx + x * win.cw, winy = borderpx + y * win.ch,
@@ -1463,47 +1468,40 @@ xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, i
 	if (base.mode & ATTR_INVISIBLE)
 		fg = bg;
 
-	/* Intelligent cleaning up of the borders. */
+    if (dmode & DRAW_BG) {
-	if (x == 0) {
+        /* Intelligent cleaning up of the borders. */
-		xclear(0, (y == 0)? 0 : winy, borderpx,
+        if (x == 0) {
-			winy + win.ch +
+            xclear(0, (y == 0)? 0 : winy, borderpx,
-			((winy + win.ch >= borderpx + win.th)? win.h : 0));
+                   winy + win.ch +
-	}
+                   ((winy + win.ch >= borderpx + win.th)? win.h : 0));
-	if (winx + width >= borderpx + win.tw) {
+        }
-		xclear(winx + width, (y == 0)? 0 : winy, win.w,
+        if (winx + width >= borderpx + win.tw) {
-			((winy + win.ch >= borderpx + win.th)? win.h : (winy + win.ch)));
+            xclear(winx + width, (y == 0)? 0 : winy, win.w,
-	}
+                   ((winy + win.ch >= borderpx + win.th)? win.h : (winy + win.ch)));
-	if (y == 0)
+        }
-		xclear(winx, 0, winx + width, borderpx);
+        if (y == 0)
-	if (winy + win.ch >= borderpx + win.th)
+            xclear(winx, 0, winx + width, borderpx);
-		xclear(winx, winy + win.ch, winx + width, win.h);
+        if (winy + win.ch >= borderpx + win.th)
+            xclear(winx, winy + win.ch, winx + width, win.h);
+        /* Fill the background */
+        XftDrawRect(xw.draw, bg, winx, winy, width, win.ch);
+    }
 
-	/* Clean up the region we want to draw to. */
+    if (dmode & DRAW_FG) {
-	XftDrawRect(xw.draw, bg, winx, winy, width, win.ch);
+        /* Render the glyphs. */
+        XftDrawGlyphFontSpec(xw.draw, fg, specs, len);
 
-	/* Set the clip region because Xft is sometimes dirty. */
+        /* Render underline and strikethrough. */
-	r.x = 0;
+        if (base.mode & ATTR_UNDERLINE) {
-	r.y = 0;
+            XftDrawRect(xw.draw, fg, winx, winy + dc.font.ascent + 1,
-	r.height = win.ch;
+                        width, 1);
-	r.width = width;
+        }
-	XftDrawSetClipRectangles(xw.draw, winx, winy, &r, 1);
 
-	/* Render the glyphs. */
+        if (base.mode & ATTR_STRUCK) {
-	XftDrawGlyphFontSpec(xw.draw, fg, specs, len);
+            XftDrawRect(xw.draw, fg, winx, winy + 2 * dc.font.ascent / 3,
-
+                        width, 1);
-	/* Render underline and strikethrough. */
+        }
-	if (base.mode & ATTR_UNDERLINE) {
+    }
-		XftDrawRect(xw.draw, fg, winx, winy + dc.font.ascent * chscale + 1,
-				width, 1);
-	}
-
-	if (base.mode & ATTR_STRUCK) {
-		XftDrawRect(xw.draw, fg, winx, winy + 2 * dc.font.ascent * chscale / 3,
-				width, 1);
-	}
-
-	/* Reset clip to none. */
-	XftDrawSetClip(xw.draw, 0);
 }
 
 void
@@ -1513,7 +1511,7 @@ xdrawglyph(Glyph g, int x, int y)
 	XftGlyphFontSpec spec;
 
 	numspecs = xmakeglyphfontspecs(&spec, &g, 1, x, y);
-	xdrawglyphfontspecs(&spec, g, numspecs, x, y);
+	xdrawglyphfontspecs(&spec, g, numspecs, x, y, DRAW_BG | DRAW_FG);
 }
 
 void
@@ -1648,32 +1646,39 @@ xstartdraw(void)
 void
 xdrawline(Line line, int x1, int y1, int x2)
 {
-	int i, x, ox, numspecs;
+	int i, x, ox, numspecs, numspecs_cached;
 	Glyph base, new;
-	XftGlyphFontSpec *specs = xw.specbuf;
+	XftGlyphFontSpec *specs;
 
-	numspecs = xmakeglyphfontspecs(specs, &line[x1], x2 - x1, x1, y1);
+	numspecs_cached = xmakeglyphfontspecs(xw.specbuf, &line[x1], x2 - x1, x1, y1);
-	i = ox = 0;
+
-	for (x = x1; x < x2 && i < numspecs; x++) {
+	/* Draw line in 2 passes: background and foreground. This way wide glyphs
-		new = line[x];
+       won't get truncated (#223) */
-		if (new.mode == ATTR_WDUMMY)
+	for (int dmode = DRAW_BG; dmode <= DRAW_FG; dmode <<= 1) {
-			continue;
+		specs = xw.specbuf;
-		if (selected(x, y1))
+		numspecs = numspecs_cached;
-			new.mode ^= ATTR_REVERSE;
+		i = ox = 0;
-		if (i > 0 && ATTRCMP(base, new)) {
+		for (x = x1; x < x2 && i < numspecs; x++) {
-			xdrawglyphfontspecs(specs, base, i, ox, y1);
+			new = line[x];
-			specs += i;
+			if (new.mode == ATTR_WDUMMY)
-			numspecs -= i;
+				continue;
-			i = 0;
+			if (selected(x, y1))
+				new.mode ^= ATTR_REVERSE;
+			if (i > 0 && ATTRCMP(base, new)) {
+				xdrawglyphfontspecs(specs, base, i, ox, y1, dmode);
+				specs += i;
+				numspecs -= i;
+				i = 0;
+			}
+			if (i == 0) {
+				ox = x;
+				base = new;
+			}
+			i++;
 		}
-		if (i == 0) {
+		if (i > 0)
-			ox = x;
+			xdrawglyphfontspecs(specs, base, i, ox, y1, dmode);
-			base = new;
-		}
-		i++;
 	}
-	if (i > 0)
-		xdrawglyphfontspecs(specs, base, i, ox, y1);
 }
 
 void
@@ -2027,6 +2032,47 @@ usage(void)
 	    " [stty_args ...]\n", argv0, argv0);
 }
 
+void
+nextscheme(const Arg *arg)
+{
+	colorscheme += arg->i;
+	if (colorscheme >= (int)LEN(schemes))
+		colorscheme = 0;
+	else if (colorscheme < 0)
+		colorscheme = LEN(schemes) - 1;
+	updatescheme();
+}
+
+void
+selectscheme(const Arg *arg)
+{
+	if (BETWEEN(arg->i, 0, LEN(schemes)-1)) {
+		colorscheme = arg->i;
+		updatescheme();
+	}
+}
+
+void
+updatescheme(void)
+{
+	int oldbg, oldfg;
+
+	oldbg = defaultbg;
+	oldfg = defaultfg;
+	colorname = schemes[colorscheme].colors;
+	defaultbg = schemes[colorscheme].bg;
+	defaultfg = schemes[colorscheme].fg;
+	defaultcs = schemes[colorscheme].cs;
+	defaultrcs = schemes[colorscheme].rcs;
+	xloadcols();
+	if (defaultbg != oldbg)
+		tupdatebgcolor(oldbg, defaultbg);
+	if (defaultfg != oldfg)
+		tupdatefgcolor(oldfg, defaultfg);
+	cresize(win.w, win.h);
+	redraw();
+}
+
 int
 main(int argc, char *argv[])
 {
@@ -2079,6 +2125,12 @@ main(int argc, char *argv[])
 	} ARGEND;
 
 run:
+	colorname = schemes[colorscheme].colors;
+	defaultbg = schemes[colorscheme].bg;
+	defaultfg = schemes[colorscheme].fg;
+	defaultcs = schemes[colorscheme].cs;
+	defaultrcs = schemes[colorscheme].rcs;
+
 	if (argc > 0) /* eat all remaining arguments */
 		opt_cmd = argv;