Yessiest
2 years ago
14 changed files with 2082 additions and 10 deletions
-
3.gitignore
-
474config.h
-
152patches/st-anysize-0.8.4.diff
-
208patches/st-csi_22_23-0.8.5.diff
-
48patches/st-desktopentry-0.8.4.diff
-
25patches/st-scrollback-mouse-20220127-2c5edf2.diff
-
78patches/st-scrollback-mouse-altscreen-20220127-2c5edf2.diff
-
730patches/st-scrollback-ringbuffer-0.8.5.diff
-
153patches/st-xresources-signal-reloading-20220407-ef05519.diff
-
16patches/st-xterm-compat.diff
-
36st.c
-
4st.info
-
4win.h
-
161x.c
@ -0,0 +1,3 @@ |
|||
*.o |
|||
*.orig |
|||
/st |
@ -0,0 +1,474 @@ |
|||
/* See LICENSE file for copyright and license details. */ |
|||
|
|||
/* |
|||
* appearance |
|||
* |
|||
* font: see http://freedesktop.org/software/fontconfig/fontconfig-user.html |
|||
*/ |
|||
static char *font = "Liberation Mono:pixelsize=12:antialias=true:autohint=true"; |
|||
static int borderpx = 2; |
|||
|
|||
/* |
|||
* What program is execed by st depends of these precedence rules: |
|||
* 1: program passed with -e |
|||
* 2: 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 = 8; |
|||
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; |
|||
|
|||
/* 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 = 2; |
|||
|
|||
/* |
|||
* Default columns and rows numbers |
|||
*/ |
|||
|
|||
static unsigned int cols = 80; |
|||
static unsigned int rows = 24; |
|||
|
|||
/* |
|||
* Default colour and shape of the mouse cursor |
|||
*/ |
|||
static unsigned int mouseshape = XC_xterm; |
|||
static unsigned int mousefg = 7; |
|||
static unsigned int mousebg = 0; |
|||
|
|||
/* |
|||
* Color used to display font attributes when fontconfig selected a font which |
|||
* doesn't match the ones requested. |
|||
*/ |
|||
static unsigned int defaultattr = 11; |
|||
|
|||
/* |
|||
* 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 */ |
|||
{ 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} }, |
|||
}; |
|||
|
|||
/* |
|||
* 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{|}~"; |
@ -0,0 +1,152 @@ |
|||
diff --git a/x.c b/x.c
|
|||
index 8bf998e..e2cda07 100644
|
|||
--- a/x.c
|
|||
+++ b/x.c
|
|||
@@ -81,6 +81,7 @@ typedef XftGlyphFontSpec GlyphFontSpec;
|
|||
typedef struct { |
|||
int tw, th; /* tty width and height */ |
|||
int w, h; /* window width and height */ |
|||
+ int hborderpx, vborderpx;
|
|||
int ch; /* char height */ |
|||
int cw; /* char width */ |
|||
int mode; /* window state/mode flags */ |
|||
@@ -331,7 +332,7 @@ ttysend(const Arg *arg)
|
|||
int |
|||
evcol(XEvent *e) |
|||
{ |
|||
- int x = e->xbutton.x - borderpx;
|
|||
+ int x = e->xbutton.x - win.hborderpx;
|
|||
LIMIT(x, 0, win.tw - 1); |
|||
return x / win.cw; |
|||
} |
|||
@@ -339,7 +340,7 @@ evcol(XEvent *e)
|
|||
int |
|||
evrow(XEvent *e) |
|||
{ |
|||
- int y = e->xbutton.y - borderpx;
|
|||
+ int y = e->xbutton.y - win.vborderpx;
|
|||
LIMIT(y, 0, win.th - 1); |
|||
return y / win.ch; |
|||
} |
|||
@@ -723,6 +724,9 @@ cresize(int width, int height)
|
|||
col = MAX(1, col); |
|||
row = MAX(1, row); |
|||
|
|||
+ win.hborderpx = (win.w - col * win.cw) / 2;
|
|||
+ win.vborderpx = (win.h - row * win.ch) / 2;
|
|||
+
|
|||
tresize(col, row); |
|||
xresize(col, row); |
|||
ttyresize(win.tw, win.th); |
|||
@@ -840,8 +844,8 @@ xhints(void)
|
|||
sizeh->flags = PSize | PResizeInc | PBaseSize | PMinSize; |
|||
sizeh->height = win.h; |
|||
sizeh->width = win.w; |
|||
- sizeh->height_inc = win.ch;
|
|||
- sizeh->width_inc = win.cw;
|
|||
+ sizeh->height_inc = 1;
|
|||
+ sizeh->width_inc = 1;
|
|||
sizeh->base_height = 2 * borderpx; |
|||
sizeh->base_width = 2 * borderpx; |
|||
sizeh->min_height = win.ch + 2 * borderpx; |
|||
@@ -1123,8 +1127,8 @@ xinit(int cols, int rows)
|
|||
xloadcols(); |
|||
|
|||
/* adjust fixed window geometry */ |
|||
- win.w = 2 * borderpx + cols * win.cw;
|
|||
- win.h = 2 * borderpx + rows * win.ch;
|
|||
+ win.w = 2 * win.hborderpx + 2 * borderpx + cols * win.cw;
|
|||
+ win.h = 2 * win.vborderpx + 2 * borderpx + rows * win.ch;
|
|||
if (xw.gm & XNegative) |
|||
xw.l += DisplayWidth(xw.dpy, xw.scr) - win.w - 2; |
|||
if (xw.gm & YNegative) |
|||
@@ -1213,7 +1217,7 @@ xinit(int cols, int rows)
|
|||
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;
|
|||
+ float winx = win.hborderpx + x * win.cw, winy = win.vborderpx + y * win.ch, xp, yp;
|
|||
ushort mode, prevmode = USHRT_MAX; |
|||
Font *font = &dc.font; |
|||
int frcflags = FRC_NORMAL; |
|||
@@ -1346,7 +1350,7 @@ void
|
|||
xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, int y) |
|||
{ |
|||
int charlen = len * ((base.mode & ATTR_WIDE) ? 2 : 1); |
|||
- int winx = borderpx + x * win.cw, winy = borderpx + y * win.ch,
|
|||
+ int winx = win.hborderpx + x * win.cw, winy = win.vborderpx + y * win.ch,
|
|||
width = charlen * win.cw; |
|||
Color *fg, *bg, *temp, revfg, revbg, truefg, truebg; |
|||
XRenderColor colfg, colbg; |
|||
@@ -1436,17 +1440,17 @@ xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, i
|
|||
|
|||
/* Intelligent cleaning up of the borders. */ |
|||
if (x == 0) { |
|||
- xclear(0, (y == 0)? 0 : winy, borderpx,
|
|||
+ xclear(0, (y == 0)? 0 : winy, win.vborderpx,
|
|||
winy + win.ch + |
|||
- ((winy + win.ch >= borderpx + win.th)? win.h : 0));
|
|||
+ ((winy + win.ch >= win.vborderpx + win.th)? win.h : 0));
|
|||
} |
|||
- if (winx + width >= borderpx + win.tw) {
|
|||
+ if (winx + width >= win.hborderpx + win.tw) {
|
|||
xclear(winx + width, (y == 0)? 0 : winy, win.w, |
|||
- ((winy + win.ch >= borderpx + win.th)? win.h : (winy + win.ch)));
|
|||
+ ((winy + win.ch >= win.vborderpx + win.th)? win.h : (winy + win.ch)));
|
|||
} |
|||
if (y == 0) |
|||
- xclear(winx, 0, winx + width, borderpx);
|
|||
- if (winy + win.ch >= borderpx + win.th)
|
|||
+ xclear(winx, 0, winx + width, win.vborderpx);
|
|||
+ if (winy + win.ch >= win.vborderpx + win.th)
|
|||
xclear(winx, winy + win.ch, winx + width, win.h); |
|||
|
|||
/* Clean up the region we want to draw to. */ |
|||
@@ -1540,35 +1544,35 @@ xdrawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og)
|
|||
case 3: /* Blinking Underline */ |
|||
case 4: /* Steady Underline */ |
|||
XftDrawRect(xw.draw, &drawcol, |
|||
- borderpx + cx * win.cw,
|
|||
- borderpx + (cy + 1) * win.ch - \
|
|||
+ win.hborderpx + cx * win.cw,
|
|||
+ win.vborderpx + (cy + 1) * win.ch - \
|
|||
cursorthickness, |
|||
win.cw, cursorthickness); |
|||
break; |
|||
case 5: /* Blinking bar */ |
|||
case 6: /* Steady bar */ |
|||
XftDrawRect(xw.draw, &drawcol, |
|||
- borderpx + cx * win.cw,
|
|||
- borderpx + cy * win.ch,
|
|||
+ win.hborderpx + cx * win.cw,
|
|||
+ win.vborderpx + cy * win.ch,
|
|||
cursorthickness, win.ch); |
|||
break; |
|||
} |
|||
} else { |
|||
XftDrawRect(xw.draw, &drawcol, |
|||
- borderpx + cx * win.cw,
|
|||
- borderpx + cy * win.ch,
|
|||
+ win.hborderpx + cx * win.cw,
|
|||
+ win.vborderpx + cy * win.ch,
|
|||
win.cw - 1, 1); |
|||
XftDrawRect(xw.draw, &drawcol, |
|||
- borderpx + cx * win.cw,
|
|||
- borderpx + cy * win.ch,
|
|||
+ win.hborderpx + cx * win.cw,
|
|||
+ win.vborderpx + cy * win.ch,
|
|||
1, win.ch - 1); |
|||
XftDrawRect(xw.draw, &drawcol, |
|||
- borderpx + (cx + 1) * win.cw - 1,
|
|||
- borderpx + cy * win.ch,
|
|||
+ win.hborderpx + (cx + 1) * win.cw - 1,
|
|||
+ win.vborderpx + cy * win.ch,
|
|||
1, win.ch - 1); |
|||
XftDrawRect(xw.draw, &drawcol, |
|||
- borderpx + cx * win.cw,
|
|||
- borderpx + (cy + 1) * win.ch - 1,
|
|||
+ win.hborderpx + cx * win.cw,
|
|||
+ win.vborderpx + (cy + 1) * win.ch - 1,
|
|||
win.cw, 1); |
|||
} |
|||
} |
@ -0,0 +1,208 @@ |
|||
From c90af45228c1100377d64ad021fa3f0cff9a1df4 Mon Sep 17 00:00:00 2001 |
|||
From: wael <40663@protonmail.com> |
|||
Date: Mon, 11 Apr 2022 21:28:43 +0300 |
|||
Subject: [PATCH] [st][patch][csi 22 23] update to 0.8.5 |
|||
|
|||
---
|
|||
st.c | 36 ++++++++++++++++++++++++++++++++---- |
|||
st.info | 4 ++-- |
|||
win.h | 4 +++- |
|||
x.c | 41 ++++++++++++++++++++++++++++++++++++++--- |
|||
4 files changed, 75 insertions(+), 10 deletions(-) |
|||
|
|||
diff --git a/st.c b/st.c
|
|||
index f43cfd3..2802381 100644
|
|||
--- a/st.c
|
|||
+++ b/st.c
|
|||
@@ -1801,6 +1801,33 @@ csihandle(void)
|
|||
goto unknown; |
|||
} |
|||
break; |
|||
+ case 't': /* title stack operations */
|
|||
+ switch (csiescseq.arg[0]) {
|
|||
+ case 22: /* pust current title on stack */
|
|||
+ switch (csiescseq.arg[1]) {
|
|||
+ case 0:
|
|||
+ case 1:
|
|||
+ case 2:
|
|||
+ xpushtitle();
|
|||
+ break;
|
|||
+ default:
|
|||
+ goto unknown;
|
|||
+ }
|
|||
+ break;
|
|||
+ case 23: /* pop last title from stack */
|
|||
+ switch (csiescseq.arg[1]) {
|
|||
+ case 0:
|
|||
+ case 1:
|
|||
+ case 2:
|
|||
+ xsettitle(NULL, 1);
|
|||
+ break;
|
|||
+ default:
|
|||
+ goto unknown;
|
|||
+ }
|
|||
+ break;
|
|||
+ default:
|
|||
+ goto unknown;
|
|||
+ }
|
|||
} |
|||
} |
|||
|
|||
@@ -1885,7 +1912,7 @@ strhandle(void)
|
|||
switch (par) { |
|||
case 0: |
|||
if (narg > 1) { |
|||
- xsettitle(strescseq.args[1]);
|
|||
+ xsettitle(strescseq.args[1], 0);
|
|||
xseticontitle(strescseq.args[1]); |
|||
} |
|||
return; |
|||
@@ -1895,7 +1922,7 @@ strhandle(void)
|
|||
return; |
|||
case 2: |
|||
if (narg > 1) |
|||
- xsettitle(strescseq.args[1]);
|
|||
+ xsettitle(strescseq.args[1], 0);
|
|||
return; |
|||
case 52: |
|||
if (narg > 2 && allowwindowops) { |
|||
@@ -1973,7 +2000,7 @@ strhandle(void)
|
|||
} |
|||
break; |
|||
case 'k': /* old title set compatibility */ |
|||
- xsettitle(strescseq.args[0]);
|
|||
+ xsettitle(strescseq.args[0], 0);
|
|||
return; |
|||
case 'P': /* DCS -- Device Control String */ |
|||
case '_': /* APC -- Application Program Command */ |
|||
@@ -2345,6 +2372,7 @@ eschandle(uchar ascii)
|
|||
break; |
|||
case 'c': /* RIS -- Reset to initial state */ |
|||
treset(); |
|||
+ xfreetitlestack();
|
|||
resettitle(); |
|||
xloadcols(); |
|||
break; |
|||
@@ -2631,7 +2659,7 @@ tresize(int col, int row)
|
|||
void |
|||
resettitle(void) |
|||
{ |
|||
- xsettitle(NULL);
|
|||
+ xsettitle(NULL, 0);
|
|||
} |
|||
|
|||
void |
|||
diff --git a/st.info b/st.info
|
|||
index 8201ad6..aeef606 100644
|
|||
--- a/st.info
|
|||
+++ b/st.info
|
|||
@@ -161,7 +161,7 @@ st-mono| simpleterm monocolor,
|
|||
rin=\E[%p1%dT, |
|||
ritm=\E[23m, |
|||
rmacs=\E(B, |
|||
- rmcup=\E[?1049l,
|
|||
+ rmcup=\E[?1049l\E[23;0;0t,
|
|||
rmir=\E[4l, |
|||
rmkx=\E[?1l\E>, |
|||
rmso=\E[27m, |
|||
@@ -172,7 +172,7 @@ st-mono| simpleterm monocolor,
|
|||
sitm=\E[3m, |
|||
sgr0=\E[0m, |
|||
smacs=\E(0, |
|||
- smcup=\E[?1049h,
|
|||
+ smcup=\E[?1049h\E[22;0;0t,
|
|||
smir=\E[4h, |
|||
smkx=\E[?1h\E=, |
|||
smso=\E[7m, |
|||
diff --git a/win.h b/win.h
|
|||
index e6e4369..ef67fd6 100644
|
|||
--- a/win.h
|
|||
+++ b/win.h
|
|||
@@ -31,7 +31,9 @@ void xfinishdraw(void);
|
|||
void xloadcols(void); |
|||
int xsetcolorname(int, const char *); |
|||
void xseticontitle(char *); |
|||
-void xsettitle(char *);
|
|||
+void xfreetitlestack(void);
|
|||
+void xsettitle(char *, int);
|
|||
+void xpushtitle(void);
|
|||
int xsetcursor(int); |
|||
void xsetmode(int, unsigned int); |
|||
void xsetpointermotion(int); |
|||
diff --git a/x.c b/x.c
|
|||
index 2a3bd38..babb04c 100644
|
|||
--- a/x.c
|
|||
+++ b/x.c
|
|||
@@ -63,6 +63,9 @@ static void ttysend(const Arg *);
|
|||
/* config.h for applying patches and the configuration. */ |
|||
#include "config.h" |
|||
|
|||
+/* size of title stack */
|
|||
+#define TITLESTACKSIZE 8
|
|||
+
|
|||
/* XEMBED messages */ |
|||
#define XEMBED_FOCUS_IN 4 |
|||
#define XEMBED_FOCUS_OUT 5 |
|||
@@ -220,6 +223,8 @@ static DC dc;
|
|||
static XWindow xw; |
|||
static XSelection xsel; |
|||
static TermWindow win; |
|||
+static int tstki; /* title stack index */
|
|||
+static char *titlestack[TITLESTACKSIZE]; /* title stack */
|
|||
|
|||
/* Font Ring Cache */ |
|||
enum { |
|||
@@ -1626,10 +1631,30 @@ xseticontitle(char *p)
|
|||
} |
|||
|
|||
void |
|||
-xsettitle(char *p)
|
|||
+xfreetitlestack(void)
|
|||
{ |
|||
- XTextProperty prop;
|
|||
- DEFAULT(p, opt_title);
|
|||
+ for (int i = 0; i < LEN(titlestack); i++) {
|
|||
+ free(titlestack[i]);
|
|||
+ titlestack[i] = NULL;
|
|||
+ }
|
|||
+}
|
|||
+
|
|||
+void
|
|||
+xsettitle(char *p, int pop)
|
|||
+{
|
|||
+ XTextProperty prop;
|
|||
+
|
|||
+ free(titlestack[tstki]);
|
|||
+ if (pop) {
|
|||
+ titlestack[tstki] = NULL;
|
|||
+ tstki = (tstki - 1 + TITLESTACKSIZE) % TITLESTACKSIZE;
|
|||
+ p = titlestack[tstki] ? titlestack[tstki] : opt_title;
|
|||
+ } else if (p) {
|
|||
+ titlestack[tstki] = xstrdup(p);
|
|||
+ } else {
|
|||
+ titlestack[tstki] = NULL;
|
|||
+ p = opt_title;
|
|||
+ }
|
|||
|
|||
if (Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle, |
|||
&prop) != Success) |
|||
@@ -1639,6 +1664,16 @@ xsettitle(char *p)
|
|||
XFree(prop.value); |
|||
} |
|||
|
|||
+void
|
|||
+xpushtitle(void)
|
|||
+{
|
|||
+ int tstkin = (tstki + 1) % TITLESTACKSIZE;
|
|||
+
|
|||
+ free(titlestack[tstkin]);
|
|||
+ titlestack[tstkin] = titlestack[tstki] ? xstrdup(titlestack[tstki]) : NULL;
|
|||
+ tstki = tstkin;
|
|||
+}
|
|||
+
|
|||
int |
|||
xstartdraw(void) |
|||
{ |
|||
--
|
|||
2.35.1 |
|||
|
@ -0,0 +1,48 @@ |
|||
From b9ce8f6df1d2318d2aa8ec9668ec227cfe327e5c Mon Sep 17 00:00:00 2001 |
|||
From: aleks <aleks.stier@icloud.com> |
|||
Date: Wed, 27 May 2020 01:35:15 +0200 |
|||
Subject: [PATCH] Create a desktop-entry for st |
|||
|
|||
Creates a desktop-entry for st. This enables to find st in a graphical |
|||
menu and to display it with a nice icon. |
|||
|
|||
---
|
|||
Makefile | 3 +++ |
|||
st.desktop | 8 ++++++++ |
|||
2 files changed, 11 insertions(+) |
|||
create mode 100644 st.desktop |
|||
|
|||
diff --git a/Makefile b/Makefile
|
|||
index fd1321e..6e79a1c 100644
|
|||
--- a/Makefile
|
|||
+++ b/Makefile
|
|||
@@ -49,9 +49,12 @@ install: st
|
|||
chmod 644 $(DESTDIR)$(MANPREFIX)/man1/st.1 |
|||
tic -sx st.info |
|||
@echo Please see the README file regarding the terminfo entry of st. |
|||
+ mkdir -p $(DESTDIR)$(PREFIX)/share/applications
|
|||
+ cp -f st.desktop $(DESTDIR)$(PREFIX)/share/applications
|
|||
|
|||
uninstall: |
|||
rm -f $(DESTDIR)$(PREFIX)/bin/st |
|||
rm -f $(DESTDIR)$(MANPREFIX)/man1/st.1 |
|||
+ rm -f $(DESTDIR)$(PREFIX)/share/applications/st.desktop
|
|||
|
|||
.PHONY: all options clean dist install uninstall |
|||
diff --git a/st.desktop b/st.desktop
|
|||
new file mode 100644 |
|||
index 0000000..e4e0714
|
|||
--- /dev/null
|
|||
+++ b/st.desktop
|
|||
@@ -0,0 +1,8 @@
|
|||
+[Desktop Entry]
|
|||
+Name=st
|
|||
+Comment=st is a simple terminal implementation for X
|
|||
+Exec=st
|
|||
+Icon=utilities-terminal
|
|||
+Terminal=false
|
|||
+Type=Application
|
|||
+Categories=System;TerminalEmulator;
|
|||
--
|
|||
2.31.0 |
|||
|
@ -0,0 +1,25 @@ |
|||
From b5d3351a21442a842e01e8c0317603b6890b379c Mon Sep 17 00:00:00 2001 |
|||
From: asparagii <michele.lambertucci1@gmail.com> |
|||
Date: Thu, 27 Jan 2022 15:44:02 +0100 |
|||
Subject: [PATCH] st-scrollback-mouse |
|||
|
|||
---
|
|||
config.def.h | 2 ++ |
|||
1 file changed, 2 insertions(+) |
|||
|
|||
diff --git a/config.def.h b/config.def.h
|
|||
index e3b469b..c217315 100644
|
|||
--- a/config.def.h
|
|||
+++ b/config.def.h
|
|||
@@ -176,6 +176,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"} }, |
|||
--
|
|||
2.34.1 |
|||
|
@ -0,0 +1,78 @@ |
|||
From 580e3f386e9215707100e9ba44797701943fd927 Mon Sep 17 00:00:00 2001 |
|||
From: asparagii <michele.lambertucci1@gmail.com> |
|||
Date: Thu, 27 Jan 2022 15:49:27 +0100 |
|||
Subject: [PATCH] st-scrollback-mouse-altscreen |
|||
|
|||
---
|
|||
config.def.h | 4 ++-- |
|||
st.c | 5 +++++ |
|||
st.h | 1 + |
|||
x.c | 2 ++ |
|||
4 files changed, 10 insertions(+), 2 deletions(-) |
|||
|
|||
diff --git a/config.def.h b/config.def.h
|
|||
index c217315..c223706 100644
|
|||
--- a/config.def.h
|
|||
+++ b/config.def.h
|
|||
@@ -176,8 +176,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, Button4, kscrollup, {.i = 1}, 0, /* !alt */ -1 },
|
|||
+ { XK_ANY_MOD, Button5, kscrolldown, {.i = 1}, 0, /* !alt */ -1 },
|
|||
{ XK_ANY_MOD, Button2, selpaste, {.i = 0}, 1 }, |
|||
{ ShiftMask, Button4, ttysend, {.s = "\033[5;2~"} }, |
|||
{ XK_ANY_MOD, Button4, ttysend, {.s = "\031"} }, |
|||
diff --git a/st.c b/st.c
|
|||
index f3af82b..876a6bf 100644
|
|||
--- a/st.c
|
|||
+++ b/st.c
|
|||
@@ -1060,6 +1060,11 @@ tnew(int col, int row)
|
|||
treset(); |
|||
} |
|||
|
|||
+int tisaltscr(void)
|
|||
+{
|
|||
+ return IS_SET(MODE_ALTSCREEN);
|
|||
+}
|
|||
+
|
|||
void |
|||
tswapscreen(void) |
|||
{ |
|||
diff --git a/st.h b/st.h
|
|||
index da36b34..e95c6f8 100644
|
|||
--- a/st.h
|
|||
+++ b/st.h
|
|||
@@ -89,6 +89,7 @@ void sendbreak(const Arg *);
|
|||
void toggleprinter(const Arg *); |
|||
|
|||
int tattrset(int); |
|||
+int tisaltscr(void);
|
|||
void tnew(int, int); |
|||
void tresize(int, int); |
|||
void tsetdirtattr(int); |
|||
diff --git a/x.c b/x.c
|
|||
index cd96575..9274556 100644
|
|||
--- a/x.c
|
|||
+++ b/x.c
|
|||
@@ -34,6 +34,7 @@ typedef struct {
|
|||
void (*func)(const Arg *); |
|||
const Arg arg; |
|||
uint release; |
|||
+ int altscrn; /* 0: don't care, -1: not alt screen, 1: alt screen */
|
|||
} MouseShortcut; |
|||
|
|||
typedef struct { |
|||
@@ -455,6 +456,7 @@ mouseaction(XEvent *e, uint release)
|
|||
for (ms = mshortcuts; ms < mshortcuts + LEN(mshortcuts); ms++) { |
|||
if (ms->release == release && |
|||
ms->button == e->xbutton.button && |
|||
+ (!ms->altscrn || (ms->altscrn == (tisaltscr() ? 1 : -1))) &&
|
|||
(match(ms->mod, state) || /* exact or forced */ |
|||
match(ms->mod, state & ~forcemousemod))) { |
|||
ms->func(&(ms->arg)); |
|||
--
|
|||
2.34.1 |
|||
|
@ -0,0 +1,730 @@ |
|||
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. |
|||
|
|||
diff --git a/config.def.h b/config.def.h
|
|||
index 91ab8ca..e3b469b 100644
|
|||
--- a/config.def.h
|
|||
+++ b/config.def.h
|
|||
@@ -201,6 +201,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} },
|
|||
}; |
|||
|
|||
/* |
|||
diff --git a/st.c b/st.c
|
|||
index 51049ba..f9e24ba 100644
|
|||
--- a/st.c
|
|||
+++ b/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 */
|
|||
- Line *alt; /* alternate screen */
|
|||
+ LineBuffer screen[2]; /* screen and alternate screen */
|
|||
+ int linelen; /* allocated line length */
|
|||
int *dirty; /* dirtyness of lines */ |
|||
TCursor c; /* cursor */ |
|||
int ocx; /* old cursor col */ |
|||
@@ -202,6 +215,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); |
|||
@@ -415,11 +430,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; |
|||
@@ -528,7 +544,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; |
|||
@@ -543,14 +559,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))) |
|||
@@ -571,14 +587,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; |
|||
} |
|||
@@ -609,13 +625,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; |
|||
|
|||
@@ -956,12 +972,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; |
|||
@@ -983,14 +1002,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;
|
|||
} |
|||
} |
|||
|
|||
@@ -1003,27 +1025,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];
|
|||
- tmoveto(c[alt].x, c[alt].y);
|
|||
+ term.c = TSCREEN.sc;
|
|||
+ tmoveto(term.c.x, term.c.y);
|
|||
} |
|||
} |
|||
|
|||
void |
|||
treset(void) |
|||
{ |
|||
- uint i;
|
|||
-
|
|||
- term.c = (TCursor){{
|
|||
- .mode = ATTR_NULL,
|
|||
- .fg = defaultfg,
|
|||
- .bg = defaultbg
|
|||
- }, .x = 0, .y = 0, .state = CURSOR_DEFAULT};
|
|||
+ int i, j;
|
|||
+ Glyph g = (Glyph){ .fg = defaultfg, .bg = defaultbg};
|
|||
|
|||
memset(term.tabs, 0, term.col * sizeof(*term.tabs)); |
|||
for (i = tabspaces; i < term.col; i += tabspaces) |
|||
@@ -1035,17 +1049,37 @@ treset(void)
|
|||
term.charset = 0; |
|||
|
|||
for (i = 0; i < 2; i++) { |
|||
- tmoveto(0, 0);
|
|||
- tcursor(CURSOR_SAVE);
|
|||
- tclearregion(0, 0, term.col-1, term.row-1);
|
|||
- tswapscreen();
|
|||
+ term.screen[i].sc = (TCursor){{
|
|||
+ .fg = defaultfg,
|
|||
+ .bg = defaultbg
|
|||
+ }};
|
|||
+ 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(); |
|||
} |
|||
@@ -1053,14 +1087,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) |
|||
{ |
|||
@@ -1069,15 +1131,29 @@ tscrolldown(int orig, int n)
|
|||
|
|||
LIMIT(n, 0, term.bot-orig+1); |
|||
|
|||
- tsetdirt(orig, term.bot-n);
|
|||
- tclearregion(0, term.bot-n+1, term.col-1, term.bot);
|
|||
+ /* Ensure that lines are allocated */
|
|||
+ 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); |
|||
} |
|||
|
|||
@@ -1089,15 +1165,29 @@ tscrollup(int orig, int n)
|
|||
|
|||
LIMIT(n, 0, term.bot-orig+1); |
|||
|
|||
- tclearregion(0, orig, term.col-1, orig+n-1);
|
|||
- tsetdirt(orig+n, term.bot);
|
|||
+ /* Ensure that lines are allocated */
|
|||
+ 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); |
|||
} |
|||
|
|||
@@ -1201,6 +1291,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. |
|||
@@ -1209,25 +1300,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 = ' ';
|
|||
- term.line[y][x+1].mode &= ~ATTR_WDUMMY;
|
|||
+ line[x+1].u = ' ';
|
|||
+ line[x+1].mode &= ~ATTR_WDUMMY;
|
|||
} |
|||
- } else if (term.line[y][x].mode & ATTR_WDUMMY) {
|
|||
- term.line[y][x-1].u = ' ';
|
|||
- term.line[y][x-1].mode &= ~ATTR_WIDE;
|
|||
+ } else if (line[x].mode & ATTR_WDUMMY) {
|
|||
+ line[x-1].u = ' ';
|
|||
+ line[x-1].mode &= ~ATTR_WIDE;
|
|||
} |
|||
|
|||
term.dirty[y] = 1; |
|||
- term.line[y][x] = *attr;
|
|||
- term.line[y][x].u = u;
|
|||
+ line[x] = *attr;
|
|||
+ 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) |
|||
@@ -1235,15 +1326,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(x2, 0, term.col-1);
|
|||
+ LIMIT(x1, 0, term.linelen-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; |
|||
@@ -1251,6 +1343,7 @@ tclearregion(int x1, int y1, int x2, int y2)
|
|||
gp->mode = 0; |
|||
gp->u = ' '; |
|||
} |
|||
+ L = (L + 1) % TSCREEN.size;
|
|||
} |
|||
} |
|||
|
|||
@@ -1265,7 +1358,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); |
|||
@@ -1282,7 +1375,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); |
|||
@@ -2103,7 +2196,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) |
|||
@@ -2486,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) |
|||
@@ -2498,7 +2591,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); |
|||
@@ -2529,6 +2622,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 */ |
|||
@@ -2555,56 +2653,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; |
|||
} |
|||
|
|||
- /*
|
|||
- * slide screen to keep cursor where we expect it -
|
|||
- * tscrollup would work here, but we can optimize to
|
|||
- * memmove because we're freeing the earlier lines
|
|||
- */
|
|||
- for (i = 0; i <= term.c.y - row; i++) {
|
|||
- free(term.line[i]);
|
|||
- free(term.alt[i]);
|
|||
+ /* Shift buffer to keep the cursor where we expect it */
|
|||
+ if (row <= term.c.y) {
|
|||
+ term.screen[0].cur = (term.screen[0].cur - row + term.c.y + 1) % term.screen[0].size;
|
|||
+ }
|
|||
+
|
|||
+ /* Resize and clear line buffers as needed */
|
|||
+ if (linelen > term.linelen) {
|
|||
+ 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);
|
|||
+ }
|
|||
} |
|||
- /* ensure that both src and dst are not NULL */
|
|||
- if (i > 0) {
|
|||
- memmove(term.line, term.line + i, row * sizeof(Line));
|
|||
- memmove(term.alt, term.alt + i, row * sizeof(Line));
|
|||
+ /* Allocate all visible lines for regular line buffer */
|
|||
+ for (j = term.screen[0].cur, i = 0; i < row; ++i, j = (j + 1) % term.screen[0].size)
|
|||
+ {
|
|||
+ 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);
|
|||
+ }
|
|||
} |
|||
- for (i += row; i < term.row; i++) {
|
|||
- free(term.line[i]);
|
|||
- free(term.alt[i]);
|
|||
+ /* 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 */
|
|||
- 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));
|
|||
- }
|
|||
+ /* fix tabstops */
|
|||
if (col > term.col) { |
|||
bp = term.tabs + term.col; |
|||
|
|||
@@ -2614,26 +2741,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) */
|
|||
- 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;
|
|||
+ tfulldirt();
|
|||
} |
|||
|
|||
void |
|||
@@ -2645,14 +2762,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])
|
|||
- continue;
|
|||
-
|
|||
- term.dirty[y] = 0;
|
|||
- xdrawline(term.line[y], x1, y, x2);
|
|||
+ if (term.dirty[y]) {
|
|||
+ term.dirty[y] = 0;
|
|||
+ xdrawline(TSCREEN.buffer[L], x1, y, x2);
|
|||
+ }
|
|||
+ L = (L + 1) % TSCREEN.size;
|
|||
} |
|||
} |
|||
|
|||
@@ -2667,14 +2785,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],
|
|||
- term.ocx, term.ocy, term.line[term.ocy][term.ocx]);
|
|||
+ if (TSCREEN.off == 0)
|
|||
+ 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(); |
|||
diff --git a/st.h b/st.h
|
|||
index 519b9bd..b48e810 100644
|
|||
--- a/st.h
|
|||
+++ b/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, |
|||
diff --git a/x.c b/x.c
|
|||
index 8a16faa..1bb5853 100644
|
|||
--- a/x.c
|
|||
+++ b/x.c
|
|||
@@ -59,6 +59,8 @@ static void zoom(const Arg *);
|
|||
static void zoomabs(const Arg *); |
|||
static void zoomreset(const Arg *); |
|||
static void ttysend(const Arg *); |
|||
+void kscrollup(const Arg *);
|
|||
+void kscrolldown(const Arg *);
|
|||
|
|||
/* config.h for applying patches and the configuration. */ |
|||
#include "config.h" |
@ -0,0 +1,153 @@ |
|||
From b2a9c96cc3c9152c4e8188f341606c914741cb50 Mon Sep 17 00:00:00 2001 |
|||
From: wael <40663@protonmail.com> |
|||
Date: Thu, 7 Apr 2022 17:14:02 +0300 |
|||
Subject: [PATCH] fix xresources with signal reloading removing arg.h and st.h |
|||
& remove unneccesary xresources variables(?) |
|||
|
|||
---
|
|||
x.c | 115 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
|||
1 file changed, 115 insertions(+) |
|||
|
|||
diff --git a/x.c b/x.c
|
|||
index 2a3bd38..e8fe7ad 100644
|
|||
--- a/x.c
|
|||
+++ b/x.c
|
|||
@@ -14,6 +14,7 @@
|
|||
#include <X11/keysym.h> |
|||
#include <X11/Xft/Xft.h> |
|||
#include <X11/XKBlib.h> |
|||
+#include <X11/Xresource.h>
|
|||
|
|||
char *argv0; |
|||
#include "arg.h" |
|||
@@ -2011,6 +2012,118 @@ run(void)
|
|||
} |
|||
} |
|||
|
|||
+
|
|||
+#define XRESOURCE_LOAD_META(NAME) \
|
|||
+ if(!XrmGetResource(xrdb, "st." NAME, "st." NAME, &type, &ret)) \
|
|||
+ XrmGetResource(xrdb, "*." NAME, "*." NAME, &type, &ret); \
|
|||
+ if (ret.addr != NULL && !strncmp("String", type, 64))
|
|||
+
|
|||
+#define XRESOURCE_LOAD_STRING(NAME, DST) \
|
|||
+ XRESOURCE_LOAD_META(NAME) \
|
|||
+ DST = ret.addr;
|
|||
+
|
|||
+#define XRESOURCE_LOAD_CHAR(NAME, DST) \
|
|||
+ XRESOURCE_LOAD_META(NAME) \
|
|||
+ DST = ret.addr[0];
|
|||
+
|
|||
+#define XRESOURCE_LOAD_INTEGER(NAME, DST) \
|
|||
+ XRESOURCE_LOAD_META(NAME) \
|
|||
+ DST = strtoul(ret.addr, NULL, 10);
|
|||
+
|
|||
+#define XRESOURCE_LOAD_FLOAT(NAME, DST) \
|
|||
+ XRESOURCE_LOAD_META(NAME) \
|
|||
+ DST = strtof(ret.addr, NULL);
|
|||
+
|
|||
+void
|
|||
+xrdb_load(void)
|
|||
+{
|
|||
+ /* XXX */
|
|||
+ char *xrm;
|
|||
+ char *type;
|
|||
+ XrmDatabase xrdb;
|
|||
+ XrmValue ret;
|
|||
+ Display *dpy;
|
|||
+
|
|||
+ if(!(dpy = XOpenDisplay(NULL)))
|
|||
+ die("Can't open display\n");
|
|||
+
|
|||
+ XrmInitialize();
|
|||
+ xrm = XResourceManagerString(dpy);
|
|||
+
|
|||
+ if (xrm != NULL) {
|
|||
+ xrdb = XrmGetStringDatabase(xrm);
|
|||
+
|
|||
+ /* handling colors here without macros to do via loop. */
|
|||
+ int i = 0;
|
|||
+ char loadValue[12] = "";
|
|||
+ for (i = 0; i < 256; i++)
|
|||
+ {
|
|||
+ sprintf(loadValue, "%s%d", "st.color", i);
|
|||
+
|
|||
+ if(!XrmGetResource(xrdb, loadValue, loadValue, &type, &ret))
|
|||
+ {
|
|||
+ sprintf(loadValue, "%s%d", "*.color", i);
|
|||
+ if (!XrmGetResource(xrdb, loadValue, loadValue, &type, &ret))
|
|||
+ /* reset if not found (unless in range for defaults). */
|
|||
+ if (i > 15)
|
|||
+ colorname[i] = NULL;
|
|||
+ }
|
|||
+
|
|||
+ if (ret.addr != NULL && !strncmp("String", type, 64))
|
|||
+ colorname[i] = ret.addr;
|
|||
+ }
|
|||
+
|
|||
+ XRESOURCE_LOAD_STRING("foreground", colorname[defaultfg]);
|
|||
+ XRESOURCE_LOAD_STRING("background", colorname[defaultbg]);
|
|||
+ XRESOURCE_LOAD_STRING("cursorColor", colorname[defaultcs])
|
|||
+ else {
|
|||
+ // this looks confusing because we are chaining off of the if
|
|||
+ // in the macro. probably we should be wrapping everything blocks
|
|||
+ // so this isn't possible...
|
|||
+ defaultcs = defaultfg;
|
|||
+ }
|
|||
+ XRESOURCE_LOAD_STRING("reverse-cursor", colorname[defaultrcs])
|
|||
+ else {
|
|||
+ // see above.
|
|||
+ defaultrcs = defaultbg;
|
|||
+ }
|
|||
+
|
|||
+ XRESOURCE_LOAD_STRING("font", font);
|
|||
+ XRESOURCE_LOAD_STRING("termname", termname);
|
|||
+
|
|||
+ XRESOURCE_LOAD_INTEGER("blinktimeout", blinktimeout);
|
|||
+ XRESOURCE_LOAD_INTEGER("bellvolume", bellvolume);
|
|||
+ XRESOURCE_LOAD_INTEGER("borderpx", borderpx);
|
|||
+ XRESOURCE_LOAD_INTEGER("cursorshape", cursorshape);
|
|||
+
|
|||
+ XRESOURCE_LOAD_FLOAT("cwscale", cwscale);
|
|||
+ XRESOURCE_LOAD_FLOAT("chscale", chscale);
|
|||
+ }
|
|||
+ XFlush(dpy);
|
|||
+}
|
|||
+
|
|||
+void
|
|||
+reload(int sig)
|
|||
+{
|
|||
+ xrdb_load();
|
|||
+
|
|||
+ /* colors, fonts */
|
|||
+ xloadcols();
|
|||
+ xunloadfonts();
|
|||
+ xloadfonts(font, 0);
|
|||
+
|
|||
+ /* pretend the window just got resized */
|
|||
+ cresize(win.w, win.h);
|
|||
+
|
|||
+ redraw();
|
|||
+
|
|||
+ /* triggers re-render if we're visible. */
|
|||
+ ttywrite("\033[O", 3, 1);
|
|||
+
|
|||
+ signal(SIGUSR1, reload);
|
|||
+}
|
|||
+
|
|||
+
|
|||
void |
|||
usage(void) |
|||
{ |
|||
@@ -2084,6 +2197,8 @@ run:
|
|||
|
|||
setlocale(LC_CTYPE, ""); |
|||
XSetLocaleModifiers(""); |
|||
+ xrdb_load();
|
|||
+ signal(SIGUSR1, reload);
|
|||
cols = MAX(cols, 1); |
|||
rows = MAX(rows, 1); |
|||
tnew(cols, rows); |
|||
--
|
|||
2.35.1 |
|||
|
@ -0,0 +1,16 @@ |
|||
diff --git a/x.c b/x.c
|
|||
index 2a3bd38..a36527b 100644
|
|||
--- a/x.c
|
|||
+++ b/x.c
|
|||
@@ -985,6 +985,11 @@ xloadfonts(const char *fontstr, double fontsize)
|
|||
{ |
|||
FcPattern *pattern; |
|||
double fontval; |
|||
+ /* Remove xft: prefix to work interchangeably with xterm config */
|
|||
+ const int fontstrlen = strlen(fontstr);
|
|||
+ if (fontstrlen > 4 && (strncmp(fontstr, "xft:", 4) == 0)) {
|
|||
+ fontstr = fontstr+4;
|
|||
+ }
|
|||
|
|||
if (fontstr[0] == '-') |
|||
pattern = XftXlfdParse(fontstr, False, False); |
Write
Preview
Loading…
Cancel
Save
Reference in new issue