fix: agree st-autocomplete with st-scrollback-ringbuffer

(apply st-scrollback-ringbuffer-0.9.2.diff)

from the patch header:

commit 0663bdf11a409961da5b1120741a69814da8ce65
Author: Timo Röhling <timo@gaussglocke.de>
Date:   Tue Nov 23 19:45:33 2021 +0100

    Terminal scrollback with ring buffer

    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.

Makefile

@@ -38,6 +38,8 @@ install: st
 	mkdir -p $(DESTDIR)$(PREFIX)/bin
 	cp -f st $(DESTDIR)$(PREFIX)/bin
 	chmod 755 $(DESTDIR)$(PREFIX)/bin/st
+	cp -f st-autocomplete $(DESTDIR)$(PREFIX)/bin
+	chmod 755 $(DESTDIR)$(PREFIX)/bin/st-autocomplete
 	mkdir -p $(DESTDIR)$(MANPREFIX)/man1
 	sed "s/VERSION/$(VERSION)/g" < st.1 > $(DESTDIR)$(MANPREFIX)/man1/st.1
 	chmod 644 $(DESTDIR)$(MANPREFIX)/man1/st.1
@@ -46,6 +48,7 @@ install: st
 
 uninstall:
 	rm -f $(DESTDIR)$(PREFIX)/bin/st
+	rm -f $(DESTDIR)$(PREFIX)/bin/st-autocomplete
 	rm -f $(DESTDIR)$(MANPREFIX)/man1/st.1
 
 .PHONY: all clean dist install uninstall

autocomplete.h

@@ -0,0 +1,16 @@
+# ifndef __ST_AUTOCOMPLETE_H
+# define __ST_AUTOCOMPLETE_H
+
+enum {
+	ACMPL_DEACTIVATE,
+	ACMPL_WORD,
+	ACMPL_WWORD,
+	ACMPL_FUZZY_WORD,
+	ACMPL_FUZZY_WWORD,
+	ACMPL_FUZZY,
+	ACMPL_SUFFIX,
+	ACMPL_SURROUND,
+	ACMPL_UNDO,
+};
+
+# endif // __ST_AUTOCOMPLETE_H

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:size=10";
 static int borderpx = 2;
 
 /*
@@ -93,46 +93,87 @@ char *termname = "st-256color";
  */
 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",
+typedef struct {
+	const char* const colors[258]; /* terminal colors */
+	unsigned int fg;               /* foreground */
+	unsigned int bg;               /* background */
+	unsigned int cs;               /* cursor */
+	unsigned int rcs;              /* reverse cursor */
+} ColorScheme;
+/*
+ * Terminal colors (16 first used in escape sequence,
+ * 2 last for custom cursor color),
+ * foreground, background, cursor, reverse cursor
+ */
+static const ColorScheme schemes[] = {
+	// st (dark)
+	{{"black", "red3", "green3", "yellow3",
+	  "blue2", "magenta3", "cyan3", "gray90",
+	  "gray50", "red", "green", "yellow",
+	  "#5c5cff", "magenta", "cyan", "white",
+	  [256]="#cccccc", "#555555"}, 7, 0, 256, 257},
 
-	/* 8 bright colors */
-	"gray50",
-	"red",
-	"green",
-	"yellow",
-	"#5c5cff",
-	"magenta",
-	"cyan",
-	"white",
+	// Alacritty (dark)
+	{{"#1d1f21", "#cc6666", "#b5bd68", "#f0c674",
+	  "#81a2be", "#b294bb", "#8abeb7", "#c5c8c6",
+	  "#666666", "#d54e53", "#b9ca4a", "#e7c547",
+	  "#7aa6da", "#c397d8", "#70c0b1", "#eaeaea",
+	  [256]="#cccccc", "#555555"}, 7, 0, 256, 257},
 
-	[255] = 0,
+	// One Half dark
+	{{"#282c34", "#e06c75", "#98c379", "#e5c07b",
+	  "#61afef", "#c678dd", "#56b6c2", "#dcdfe4",
+	  "#282c34", "#e06c75", "#98c379", "#e5c07b",
+	  "#61afef", "#c678dd", "#56b6c2", "#dcdfe4",
+	  [256]="#cccccc", "#555555"}, 7, 0, 256, 257},
 
-	/* more colors can be added after 255 to use with DefaultXX */
-	"#cccccc",
-	"#555555",
-	"gray90", /* default foreground colour */
-	"black", /* default background colour */
+	// One Half light
+	{{"#fafafa", "#e45649", "#50a14f", "#c18401",
+      "#0184bc", "#a626a4", "#0997b3", "#383a42",
+	  "#fafafa", "#e45649", "#50a14f", "#c18401",
+	  "#0184bc", "#a626a4", "#0997b3", "#383a42",
+	  [256]="#cccccc", "#555555"}, 7, 0, 256, 257},
+
+	// Lupan dark
+	{{"#1f212e", "#862d2d", "#3a783a", "#707010",
+	  "#345eb2", "#cc66cc", "#3a7878", "#a1a3aa",
+	  "#4d4d4d", "#c27070", "#40bf40", "#acac53",
+	  "#6b8ac7", "#8f248f", "#509595", "#dbdff0",
+	  [256]="#bf8040", "#555555"}, 7, 0, 256, 257},
+
+	// Lupan light
+	{{"#dae4f1", "#862d2d", "#3a783a", "#707010",
+	  "#345eb2", "#cc66cc", "#3a7878", "#a1a3aa",
+	  "#73778c", "#c27070", "#40bf40", "#acac53",
+	  "#6b8ac7", "#8f248f", "#509595", "#1f212e",
+	  [256]="#bf8040", "#555555"}, 15, 0, 256, 257},
+
+	// Gruvbox dark
+	{{"#282828", "#cc241d", "#98971a", "#d79921",
+	  "#458588", "#b16286", "#689d6a", "#a89984",
+	  "#928374", "#fb4934", "#b8bb26", "#fabd2f",
+	  "#83a598", "#d3869b", "#8ec07c", "#ebdbb2",
+	  [256]="#ebdbb2", "#555555"}, 15, 0, 256, 257},
+
+	// Gruvbox light
+	{{"#fbf1c7", "#cc241d", "#98971a", "#d79921",
+	  "#458588", "#b16286", "#689d6a", "#7c6f64",
+	  "#928374", "#9d0006", "#79740e", "#b57614",
+	  "#076678", "#8f3f71", "#427b58", "#3c3836",
+	  [256]="#3c3836", "#555555"}, 15, 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 defaultbg = 259;
-unsigned int defaultcs = 256;
-static unsigned int defaultrcs = 257;
+unsigned int defaultfg;
+unsigned int defaultbg;
+unsigned int defaultcs;
+static unsigned int defaultrcs;
 
 /*
  * Default shape of cursor
@@ -170,6 +211,8 @@ static unsigned int defaultattr = 11;
  */
 static uint forcemousemod = ShiftMask;
 
+#include "autocomplete.h"
+
 /*
  * Internal mouse shortcuts.
  * Beware that overloading Button1 will disable the selection.
@@ -187,6 +230,8 @@ static MouseShortcut mshortcuts[] = {
 #define MODKEY Mod1Mask
 #define TERMMOD (ControlMask|ShiftMask)
 
+#define ACMPL_MOD ControlMask|Mod1Mask
+
 static Shortcut shortcuts[] = {
 	/* mask                 keysym          function        argument */
 	{ XK_ANY_MOD,           XK_Break,       sendbreak,      {.i =  0} },
@@ -201,6 +246,26 @@ static Shortcut shortcuts[] = {
 	{ TERMMOD,              XK_Y,           selpaste,       {.i =  0} },
 	{ ShiftMask,            XK_Insert,      selpaste,       {.i =  0} },
 	{ TERMMOD,              XK_Num_Lock,    numlock,        {.i =  0} },
+	{ MODKEY|ControlMask,   XK_1,           selectscheme,   {.i =  0} },
+	{ MODKEY|ControlMask,   XK_2,           selectscheme,   {.i =  1} },
+	{ MODKEY|ControlMask,   XK_3,           selectscheme,   {.i =  2} },
+	{ MODKEY|ControlMask,   XK_4,           selectscheme,   {.i =  3} },
+	{ MODKEY|ControlMask,   XK_5,           selectscheme,   {.i =  4} },
+	{ MODKEY|ControlMask,   XK_6,           selectscheme,   {.i =  5} },
+	{ MODKEY|ControlMask,   XK_7,           selectscheme,   {.i =  6} },
+	{ MODKEY|ControlMask,   XK_8,           selectscheme,   {.i =  7} },
+	{ MODKEY|ControlMask,   XK_9,           nextscheme,     {.i = -1} },
+	{ MODKEY|ControlMask,   XK_0,           nextscheme,     {.i = +1} },
+	{ ShiftMask,            XK_Page_Up,     kscrollup,      {.i = -1} },
+	{ ShiftMask,            XK_Page_Down,   kscrolldown,    {.i = -1} },
+	{ ACMPL_MOD,            XK_slash,       autocomplete,   { .i = ACMPL_WORD        } },
+	{ ACMPL_MOD,            XK_period,      autocomplete,   { .i = ACMPL_FUZZY_WORD  } },
+	{ ACMPL_MOD,            XK_comma,       autocomplete,   { .i = ACMPL_FUZZY       } },
+	{ ACMPL_MOD,            XK_apostrophe,  autocomplete,   { .i = ACMPL_SUFFIX      } },
+	{ ACMPL_MOD,            XK_semicolon,   autocomplete,   { .i = ACMPL_SURROUND    } },
+	{ ACMPL_MOD,            XK_bracketright,autocomplete,   { .i = ACMPL_WWORD       } },
+	{ ACMPL_MOD,            XK_bracketleft, autocomplete,   { .i = ACMPL_FUZZY_WWORD } },
+	{ ACMPL_MOD,            XK_equal,       autocomplete,   { .i = ACMPL_UNDO        } },
 };
 
 /*

config.mk

@@ -1,5 +1,5 @@
 # st version
-VERSION = 0.9.2
+VERSION = 0.9.3
 
 # Customize below to fit your system
 

st-autocomplete

@@ -0,0 +1,310 @@
+#!/usr/bin/perl
+#########################################################################
+# Copyright (C) 2012-2017  Wojciech Siewierski                          #
+#                                                                       #
+# This program is free software: you can redistribute it and/or modify  #
+# it under the terms of the GNU General Public License as published by  #
+# the Free Software Foundation, either version 3 of the License, or     #
+# (at your option) any later version.                                   #
+#                                                                       #
+# This program is distributed in the hope that it will be useful,       #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of        #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         #
+# GNU General Public License for more details.                          #
+#                                                                       #
+# You should have received a copy of the GNU General Public License     #
+# along with this program.  If not, see <http://www.gnu.org/licenses/>. #
+#########################################################################
+
+my ($cmd, $cursor_row, $cursor_column) = @ARGV;
+
+my $lines = [];
+my $lines1 = [];
+
+my $last_line = -1;
+my $lines_before_cursor = 0;
+
+while (<stdin>)
+{
+	$last_line++;
+
+	s/[^[:print:]]/?/g;
+
+	if ($last_line < $cursor_row)
+	{
+		unshift @{$lines1}, $_;
+		$lines_before_cursor++;
+	}
+	else
+	{
+		unshift @{$lines}, $_;
+	}
+}
+
+foreach (@{$lines1})
+{
+	unshift @{$lines}, $_;
+}
+
+my $cursor_row_in = $cursor_row;
+
+$cursor_row = $last_line;
+
+
+$self = {};
+
+# A reference to a function that transforms the completed word
+# into a regex matching the completions. Usually generated by
+# generate_matcher().
+#
+# For example
+#   $fun = generate_matcher(".*");
+#   $fun->("foo");
+# would return "f.*o.*o"
+#
+# In other words, indirectly decides which characters can
+# appear in the completion.
+my $matcher;
+
+# A regular expression matching a character before each match.
+# For example, it you want to match the text after a
+# whitespace, set it to "\s".
+my $char_class_before;
+
+# A regular expression matching every character in the entered
+# text that will be used to find matching completions. Usually
+# "\w" or similar.
+my $char_class_to_complete;
+
+# A regular expression matching every allowed last character
+# of the completion (uses greedy matching).
+my $char_class_at_end;
+
+if ($cmd eq 'word-complete') {
+	# Basic word completion. Completes the current word
+	# without any special matching.
+	$char_class_before      = '[^-\w]';
+	$matcher                = sub { quotemeta shift }; # identity
+	$char_class_at_end      = '[-\w]';
+	$char_class_to_complete = '[-\w]';
+} elsif ($cmd eq 'WORD-complete') {
+	# The same as above but in the Vim meaning of a "WORD" --
+	# whitespace delimited.
+	$char_class_before      = '\s';
+	$matcher                = sub { quotemeta shift };
+	$char_class_at_end      = '\S';
+	$char_class_to_complete = '\S';
+} elsif ($cmd eq 'fuzzy-word-complete' ||
+		 $cmd eq 'skeleton-word-complete') {
+	# Fuzzy completion of the current word.
+	$char_class_before      = '[^-\w]';
+	$matcher                = generate_matcher('[-\w]*');
+	$char_class_at_end      = '[-\w]';
+	$char_class_to_complete = '[-\w]';
+} elsif ($cmd eq 'fuzzy-WORD-complete') {
+	# Fuzzy completion of the current WORD.
+	$char_class_before      = '\s';
+	$matcher                = generate_matcher('\S*');
+	$char_class_at_end      = '\S';
+	$char_class_to_complete = '\S';
+} elsif ($cmd eq 'fuzzy-complete' ||
+		 $cmd eq 'skeleton-complete') {
+	# Fuzzy completion of an arbitrary text.
+	$char_class_before      = '\W';
+	$matcher                = generate_matcher('.*?');
+	$char_class_at_end      = '\w';
+	$char_class_to_complete = '\S';
+} elsif ($cmd eq 'suffix-complete') {
+	# Fuzzy completion of an completing suffixes, like
+	# completing test=hello from /blah/hello.
+	$char_class_before      = '\S';
+	$matcher                = generate_matcher('\S*');
+	$char_class_at_end      = '\S';
+	$char_class_to_complete = '\S';
+} elsif ($cmd eq 'surround-complete') {
+	# Completing contents of quotes and braces.
+
+	# Here we are using three named groups: s, b, p for quotes, braces
+	# and parenthesis.
+	$char_class_before      = '((?<q>["\'`])|(?<b>\[)|(?<p>\())';
+
+	$matcher                = generate_matcher('.*?');
+
+	# Here we match text till enclosing pair, using perl conditionals in
+	# regexps (?(condition)yes-expression|no-expression).
+	# \0 is used to hack concatenation with '*' later in the code.
+	$char_class_at_end      = '.*?(.(?=(?(<b>)\]|((?(<p>)\)|\g{q})))))\0';
+	$char_class_to_complete = '\S';
+}
+
+
+# use the last used word or read the word behind the cursor
+my $word_to_complete = read_word_at_coord($self, $cursor_row, $cursor_column,
+										  $char_class_to_complete);
+
+print stdout "$word_to_complete\n";
+
+if ($word_to_complete) {
+	while (1) {
+		# ignore the completed word itself
+		$self->{already_completed}{$word_to_complete} = 1;
+
+		# continue the last search or start from the current row
+		my $completion = find_match($self,
+									$word_to_complete,
+									$self->{next_row} // $cursor_row,
+									$matcher->($word_to_complete),
+									$char_class_before,
+									$char_class_at_end);
+		if ($completion) {
+			print stdout $completion."\n".join ("\n", @{$self->{highlight}})."\n";
+		}
+		else {
+			last;
+		}
+	}
+}
+
+######################################################################
+
+sub highlight_match {
+    my ($self, $linenum, $completion) = @_;
+
+    # clear_highlight($self);
+
+    my $line = @{$lines}[$linenum];
+    my $re = quotemeta $completion;
+
+    $line =~ /$re/;
+
+    my $beg = $-[0];
+    my $end = $+[0];
+
+	if ($linenum >= $lines_before_cursor)
+	{
+		$lline = $last_line - $lines_before_cursor;
+		$linenum -= $lines_before_cursor;
+		$linenum = $lline - $linenum;
+		$linenum += $lines_before_cursor;
+	}
+
+
+    $self->{highlight} = [$linenum, $beg, $end];
+}
+
+######################################################################
+
+sub read_word_at_coord {
+    my ($self, $row, $col, $char_class) = @_;
+
+    $_ = substr(@{$lines} [$row], 0, $col); # get the current line up to the cursor...
+    s/.*?($char_class*)$/$1/;               # ...and read the last word from it
+    return $_;
+}
+
+######################################################################
+
+# Returns a function that takes a string and returns that string with
+# this function's argument inserted between its every two characters.
+# The resulting string is used as a regular expression matching the
+# completion candidates.
+sub generate_matcher {
+    my $regex_between = shift;
+
+    sub {
+        $_ = shift;
+
+        # sorry for this lispy code, I couldn't resist ;)
+        (join "$regex_between",
+         (map quotemeta,
+          (split //)))
+    }
+}
+
+######################################################################
+
+# Checks whether the completion found by find_match() was already
+# found and if it was, calls find_match() again to find the next
+# completion.
+#
+# Takes all the arguments that find_match() would take, to make a
+# mutually recursive call.
+sub skip_duplicates {
+    my ($self, $word_to_match, $current_row, $regexp, $char_class_before, $char_class_at_end) = @_;
+    my $completion;
+
+	if ($current_row <= $lines_before_cursor)
+	{
+		$completion = shift @{$self->{matches_in_row}}; # get the leftmost one
+	}
+	else
+	{
+		$completion = pop @{$self->{matches_in_row}}; # get the leftmost one
+	}
+
+    # check for duplicates
+    if (exists $self->{already_completed}{$completion}) {
+        # skip this completion
+        return find_match(@_);
+    } else {
+        $self->{already_completed}{$completion} = 1;
+
+		highlight_match($self,
+						$self->{next_row}+1,
+						$completion);
+
+        return $completion;
+    }
+}
+
+######################################################################
+
+# Finds the next matching completion in the row current row or above
+# while skipping duplicates using skip_duplicates().
+sub find_match {
+    my ($self, $word_to_match, $current_row, $regexp, $char_class_before, $char_class_at_end) = @_;
+    $self->{matches_in_row} //= [];
+
+    # cycle through all the matches in the current row if not starting a new search
+    if (@{$self->{matches_in_row}}) {
+        return skip_duplicates($self, $word_to_match, $current_row, $regexp, $char_class_before, $char_class_at_end);
+    }
+
+
+    my $i;
+    # search through all the rows starting with current one or one above the last checked
+    for ($i = $current_row; $i >= 0; --$i) {
+        my $line = @{$lines}[$i];   # get the line of text from the row
+
+        # if ($i == $cursor_row) {
+        #     $line = substr $line, 0, $cursor_column;
+        # }
+
+        $_ = $line;
+
+        # find all the matches in the current line
+        my $match;
+        push @{$self->{matches_in_row}}, $+{match} while ($_, $match) = /
+                                                                         (.*${char_class_before})
+                                                                         (?<match>
+                                                                             ${regexp}
+                                                                             ${char_class_at_end}*
+                                                                         )
+                                                                     /ix;
+        # corner case: match at the very beginning of line
+        push @{$self->{matches_in_row}}, $+{match} if $line =~ /^(${char_class_before}){0}(?<match>$regexp$char_class_at_end*)/i;
+
+        if (@{$self->{matches_in_row}}) {
+            # remember which row should be searched next
+            $self->{next_row} = --$i;
+
+            # arguments needed for find_match() mutual recursion
+            return skip_duplicates($self, $word_to_match, $i, $regexp, $char_class_before, $char_class_at_end);
+        }
+    }
+
+    # # no more possible completions, revert to the original word
+    # undo_completion($self) if $i < 0;
+
+    return undef;
+}

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,
@@ -77,6 +78,8 @@ typedef union {
 	const char *s;
 } Arg;
 
+void autocomplete (const Arg *);
+
 void die(const char *, ...);
 void redraw(void);
 void draw(void);
@@ -90,6 +93,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"
@@ -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 = 258;
 		dc.col = xmalloc(dc.collen * sizeof(Color));
 	}
 
@@ -1862,11 +1867,20 @@ kpress(XEvent *ev)
 	/* 1. shortcuts */
 	for (bp = shortcuts; bp < shortcuts + LEN(shortcuts); bp++) {
 		if (ksym == bp->keysym && match(bp->mod, e->state)) {
+			if (bp -> func != autocomplete)
+				autocomplete ((const Arg []) { ACMPL_DEACTIVATE });
 			bp->func(&(bp->arg));
 			return;
 		}
 	}
 
+	if (!(
+		len == 0 &&
+		e -> state & ~ignoremod		// ACMPL_ISSUE: I'm not sure that this is the right way
+				| ACMPL_MOD == ACMPL_MOD
+	))
+		autocomplete ((const Arg []) { ACMPL_DEACTIVATE });
+
 	/* 2. custom keys from config.h */
 	if ((customkey = kmap(ksym, e->state))) {
 		ttywrite(customkey, strlen(customkey), 1);
@@ -2036,6 +2050,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[])
 {
@@ -2088,6 +2143,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;