TiynGER
3 years ago
7 changed files with 2688 additions and 26 deletions
@ -0,0 +1,466 @@ |
|||
/* See LICENSE file for copyright and license details. */ |
|||
|
|||
/*
|
|||
* appearance |
|||
* |
|||
* font: see http://freedesktop.org/software/fontconfig/fontconfig-user.html
|
|||
*/ |
|||
static char *font = "mono:pixelsize=16:antialias=true:autohint=true"; |
|||
static char *font2[] = { "IBM Plex Mono:pixelsize=16: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: utmp option |
|||
* 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; |
|||
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; |
|||
|
|||
/* frames per second st should at maximum draw to the screen */ |
|||
static unsigned int xfps = 120; |
|||
static unsigned int actionfps = 30; |
|||
|
|||
/*
|
|||
* blinking timeout (set to 0 to disable blinking) for the terminal blinking |
|||
* attribute. |
|||
*/ |
|||
static unsigned int blinktimeout = 800; |
|||
|
|||
/*
|
|||
* 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 = "xterm-256color"; |
|||
|
|||
/*
|
|||
* spaces per tab |
|||
* |
|||
* When you are changing this value, don't forget to adapt the »it« value in |
|||
* the st.info and appropriately install the st.info in the environment where |
|||
* you use this st version. |
|||
* |
|||
* it#$tabspaces, |
|||
* |
|||
* Secondly make sure your kernel is not expanding tabs. When running `stty |
|||
* -a` »tab0« should appear. You can tell the terminal to not expand tabs by |
|||
* running following command: |
|||
* |
|||
* stty tabs |
|||
*/ |
|||
unsigned int tabspaces = 8; |
|||
|
|||
/*bg opacity*/ |
|||
float alpha = 0.92; |
|||
|
|||
/* Terminal colors (16 first used in escape sequence) */ |
|||
static const char *colorname[] = { |
|||
/* 8 normal colors */ |
|||
"#1f1f1f", /* hard contrast: #1d2021 / soft contrast: #32302f */ |
|||
"#f81118", |
|||
"#2dc55e", |
|||
"#ecba0f", |
|||
"#2a84d2", |
|||
"#4e5ab7", |
|||
"#1081d6", |
|||
"#d6dbe5", |
|||
"#d6dbe5", |
|||
"#de352e", |
|||
"#1dd361", |
|||
"#f3bd09", |
|||
"#1081d6", |
|||
"#5350b9", |
|||
"#0f7ddb", |
|||
"#ffffff", |
|||
[255] = 0, |
|||
/* more colors can be added after 255 to use with DefaultXX */ |
|||
"#282828", /* 256 -> bg */ |
|||
"#ebdbb2", /* 257 -> fg */ |
|||
"#add8e6", /* 258 -> cursor */ |
|||
|
|||
/* more colors can be added after 255 to use with DefaultXX */ |
|||
"#cccccc", |
|||
"#555555", |
|||
"black", |
|||
}; |
|||
|
|||
|
|||
/*
|
|||
* Default colors (colorname index) |
|||
* foreground, background, cursor, reverse cursor |
|||
*/ |
|||
unsigned int defaultfg = 257; |
|||
unsigned int defaultbg = 256; |
|||
static unsigned int defaultcs = 258; |
|||
static unsigned int defaultrcs = 0; |
|||
|
|||
/*
|
|||
* 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 */ |
|||
{ Button4, XK_NO_MOD, "\031" }, |
|||
{ Button5, XK_NO_MOD, "\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} }, |
|||
{ ShiftMask, XK_Insert, clippaste, {.i = 0} }, |
|||
{ MODKEY, XK_c, clipcopy, {.i = 0} }, |
|||
{ MODKEY, XK_v, clippaste, {.i = 0} }, |
|||
{ MODKEY, XK_p, selpaste, {.i = 0} }, |
|||
{ MODKEY, XK_Num_Lock, numlock, {.i = 0} }, |
|||
{ MODKEY, XK_k, kscrollup, {.i = 1} }, |
|||
{ MODKEY, XK_j, kscrolldown, {.i = 1} }, |
|||
{ TERMMOD, XK_U, zoom, {.f = +1} }, |
|||
{ TERMMOD, XK_U, zoom, {.f = +1} }, |
|||
{ TERMMOD, XK_I, zoom, {.f = -1} }, |
|||
}; |
|||
|
|||
/*
|
|||
* Special keys (change & recompile st.info accordingly) |
|||
* |
|||
* Mask value: |
|||
* * Use XK_ANY_MOD to match the key no matter modifiers state |
|||
* * Use XK_NO_MOD to match the key alone (no modifiers) |
|||
* appkey value: |
|||
* * 0: no value |
|||
* * > 0: keypad application mode enabled |
|||
* * = 2: term.numlock = 1 |
|||
* * < 0: keypad application mode disabled |
|||
* appcursor value: |
|||
* * 0: no value |
|||
* * > 0: cursor application mode enabled |
|||
* * < 0: cursor application mode disabled |
|||
* |
|||
* Be careful with the order of the definitions because st searches in |
|||
* this table sequentially, so any XK_ANY_MOD must be in the last |
|||
* position for a key. |
|||
*/ |
|||
|
|||
/*
|
|||
* If you want keys other than the X11 function keys (0xFD00 - 0xFFFF) |
|||
* to be mapped below, add them to this array. |
|||
*/ |
|||
static KeySym mappedkeys[] = { -1 }; |
|||
|
|||
/*
|
|||
* State bits to ignore when matching key or button events. By default, |
|||
* numlock (Mod2Mask) and keyboard layout (XK_SWITCH_MOD) are ignored. |
|||
*/ |
|||
static uint ignoremod = Mod2Mask|XK_SWITCH_MOD; |
|||
|
|||
/*
|
|||
* This is the huge key array which defines all compatibility to the Linux |
|||
* world. Please decide about changes wisely. |
|||
*/ |
|||
static Key key[] = { |
|||
/* keysym mask string appkey appcursor */ |
|||
{ XK_KP_Home, ShiftMask, "\033[2J", 0, -1}, |
|||
{ XK_KP_Home, ShiftMask, "\033[1;2H", 0, +1}, |
|||
{ XK_KP_Home, XK_ANY_MOD, "\033[H", 0, -1}, |
|||
{ XK_KP_Home, XK_ANY_MOD, "\033[1~", 0, +1}, |
|||
{ XK_KP_Up, XK_ANY_MOD, "\033Ox", +1, 0}, |
|||
{ XK_KP_Up, XK_ANY_MOD, "\033[A", 0, -1}, |
|||
{ XK_KP_Up, XK_ANY_MOD, "\033OA", 0, +1}, |
|||
{ XK_KP_Down, XK_ANY_MOD, "\033Or", +1, 0}, |
|||
{ XK_KP_Down, XK_ANY_MOD, "\033[B", 0, -1}, |
|||
{ XK_KP_Down, XK_ANY_MOD, "\033OB", 0, +1}, |
|||
{ XK_KP_Left, XK_ANY_MOD, "\033Ot", +1, 0}, |
|||
{ XK_KP_Left, XK_ANY_MOD, "\033[D", 0, -1}, |
|||
{ XK_KP_Left, XK_ANY_MOD, "\033OD", 0, +1}, |
|||
{ XK_KP_Right, XK_ANY_MOD, "\033Ov", +1, 0}, |
|||
{ XK_KP_Right, XK_ANY_MOD, "\033[C", 0, -1}, |
|||
{ XK_KP_Right, XK_ANY_MOD, "\033OC", 0, +1}, |
|||
{ XK_KP_Prior, ShiftMask, "\033[5;2~", 0, 0}, |
|||
{ XK_KP_Prior, XK_ANY_MOD, "\033[5~", 0, 0}, |
|||
{ XK_KP_Begin, XK_ANY_MOD, "\033[E", 0, 0}, |
|||
{ XK_KP_End, ControlMask, "\033[J", -1, 0}, |
|||
{ XK_KP_End, ControlMask, "\033[1;5F", +1, 0}, |
|||
{ XK_KP_End, ShiftMask, "\033[K", -1, 0}, |
|||
{ XK_KP_End, ShiftMask, "\033[1;2F", +1, 0}, |
|||
{ XK_KP_End, XK_ANY_MOD, "\033[4~", 0, 0}, |
|||
{ XK_KP_Next, ShiftMask, "\033[6;2~", 0, 0}, |
|||
{ XK_KP_Next, XK_ANY_MOD, "\033[6~", 0, 0}, |
|||
{ XK_KP_Insert, ShiftMask, "\033[2;2~", +1, 0}, |
|||
{ XK_KP_Insert, ShiftMask, "\033[4l", -1, 0}, |
|||
{ XK_KP_Insert, ControlMask, "\033[L", -1, 0}, |
|||
{ XK_KP_Insert, ControlMask, "\033[2;5~", +1, 0}, |
|||
{ XK_KP_Insert, XK_ANY_MOD, "\033[4h", -1, 0}, |
|||
{ XK_KP_Insert, XK_ANY_MOD, "\033[2~", +1, 0}, |
|||
{ XK_KP_Delete, ControlMask, "\033[M", -1, 0}, |
|||
{ XK_KP_Delete, ControlMask, "\033[3;5~", +1, 0}, |
|||
{ XK_KP_Delete, ShiftMask, "\033[2K", -1, 0}, |
|||
{ XK_KP_Delete, ShiftMask, "\033[3;2~", +1, 0}, |
|||
{ XK_KP_Delete, XK_ANY_MOD, "\033[P", -1, 0}, |
|||
{ XK_KP_Delete, XK_ANY_MOD, "\033[3~", +1, 0}, |
|||
{ XK_KP_Multiply, XK_ANY_MOD, "\033Oj", +2, 0}, |
|||
{ XK_KP_Add, XK_ANY_MOD, "\033Ok", +2, 0}, |
|||
{ XK_KP_Enter, XK_ANY_MOD, "\033OM", +2, 0}, |
|||
{ XK_KP_Enter, XK_ANY_MOD, "\r", -1, 0}, |
|||
{ XK_KP_Subtract, XK_ANY_MOD, "\033Om", +2, 0}, |
|||
{ XK_KP_Decimal, XK_ANY_MOD, "\033On", +2, 0}, |
|||
{ XK_KP_Divide, XK_ANY_MOD, "\033Oo", +2, 0}, |
|||
{ XK_KP_0, XK_ANY_MOD, "\033Op", +2, 0}, |
|||
{ XK_KP_1, XK_ANY_MOD, "\033Oq", +2, 0}, |
|||
{ XK_KP_2, XK_ANY_MOD, "\033Or", +2, 0}, |
|||
{ XK_KP_3, XK_ANY_MOD, "\033Os", +2, 0}, |
|||
{ XK_KP_4, XK_ANY_MOD, "\033Ot", +2, 0}, |
|||
{ XK_KP_5, XK_ANY_MOD, "\033Ou", +2, 0}, |
|||
{ XK_KP_6, XK_ANY_MOD, "\033Ov", +2, 0}, |
|||
{ XK_KP_7, XK_ANY_MOD, "\033Ow", +2, 0}, |
|||
{ XK_KP_8, XK_ANY_MOD, "\033Ox", +2, 0}, |
|||
{ XK_KP_9, XK_ANY_MOD, "\033Oy", +2, 0}, |
|||
{ XK_Up, ShiftMask, "\033[1;2A", 0, 0}, |
|||
{ XK_Up, Mod1Mask, "\033[1;3A", 0, 0}, |
|||
{ XK_Up, ShiftMask|Mod1Mask,"\033[1;4A", 0, 0}, |
|||
{ XK_Up, ControlMask, "\033[1;5A", 0, 0}, |
|||
{ XK_Up, ShiftMask|ControlMask,"\033[1;6A", 0, 0}, |
|||
{ XK_Up, ControlMask|Mod1Mask,"\033[1;7A", 0, 0}, |
|||
{ XK_Up,ShiftMask|ControlMask|Mod1Mask,"\033[1;8A", 0, 0}, |
|||
{ XK_Up, XK_ANY_MOD, "\033[A", 0, -1}, |
|||
{ XK_Up, XK_ANY_MOD, "\033OA", 0, +1}, |
|||
{ XK_Down, ShiftMask, "\033[1;2B", 0, 0}, |
|||
{ XK_Down, Mod1Mask, "\033[1;3B", 0, 0}, |
|||
{ XK_Down, ShiftMask|Mod1Mask,"\033[1;4B", 0, 0}, |
|||
{ XK_Down, ControlMask, "\033[1;5B", 0, 0}, |
|||
{ XK_Down, ShiftMask|ControlMask,"\033[1;6B", 0, 0}, |
|||
{ XK_Down, ControlMask|Mod1Mask,"\033[1;7B", 0, 0}, |
|||
{ XK_Down,ShiftMask|ControlMask|Mod1Mask,"\033[1;8B",0, 0}, |
|||
{ XK_Down, XK_ANY_MOD, "\033[B", 0, -1}, |
|||
{ XK_Down, XK_ANY_MOD, "\033OB", 0, +1}, |
|||
{ XK_Left, ShiftMask, "\033[1;2D", 0, 0}, |
|||
{ XK_Left, Mod1Mask, "\033[1;3D", 0, 0}, |
|||
{ XK_Left, ShiftMask|Mod1Mask,"\033[1;4D", 0, 0}, |
|||
{ XK_Left, ControlMask, "\033[1;5D", 0, 0}, |
|||
{ XK_Left, ShiftMask|ControlMask,"\033[1;6D", 0, 0}, |
|||
{ XK_Left, ControlMask|Mod1Mask,"\033[1;7D", 0, 0}, |
|||
{ XK_Left,ShiftMask|ControlMask|Mod1Mask,"\033[1;8D",0, 0}, |
|||
{ XK_Left, XK_ANY_MOD, "\033[D", 0, -1}, |
|||
{ XK_Left, XK_ANY_MOD, "\033OD", 0, +1}, |
|||
{ XK_Right, ShiftMask, "\033[1;2C", 0, 0}, |
|||
{ XK_Right, Mod1Mask, "\033[1;3C", 0, 0}, |
|||
{ XK_Right, ShiftMask|Mod1Mask,"\033[1;4C", 0, 0}, |
|||
{ XK_Right, ControlMask, "\033[1;5C", 0, 0}, |
|||
{ XK_Right, ShiftMask|ControlMask,"\033[1;6C", 0, 0}, |
|||
{ XK_Right, ControlMask|Mod1Mask,"\033[1;7C", 0, 0}, |
|||
{ XK_Right,ShiftMask|ControlMask|Mod1Mask,"\033[1;8C",0, 0}, |
|||
{ XK_Right, XK_ANY_MOD, "\033[C", 0, -1}, |
|||
{ XK_Right, XK_ANY_MOD, "\033OC", 0, +1}, |
|||
{ XK_ISO_Left_Tab, ShiftMask, "\033[Z", 0, 0}, |
|||
{ XK_Return, Mod1Mask, "\033\r", 0, 0}, |
|||
{ XK_Return, XK_ANY_MOD, "\r", 0, 0}, |
|||
{ XK_Insert, ShiftMask, "\033[4l", -1, 0}, |
|||
{ XK_Insert, ShiftMask, "\033[2;2~", +1, 0}, |
|||
{ XK_Insert, ControlMask, "\033[L", -1, 0}, |
|||
{ XK_Insert, ControlMask, "\033[2;5~", +1, 0}, |
|||
{ XK_Insert, XK_ANY_MOD, "\033[4h", -1, 0}, |
|||
{ XK_Insert, XK_ANY_MOD, "\033[2~", +1, 0}, |
|||
{ XK_Delete, ControlMask, "\033[M", -1, 0}, |
|||
{ XK_Delete, ControlMask, "\033[3;5~", +1, 0}, |
|||
{ XK_Delete, ShiftMask, "\033[2K", -1, 0}, |
|||
{ XK_Delete, ShiftMask, "\033[3;2~", +1, 0}, |
|||
{ XK_Delete, XK_ANY_MOD, "\033[P", -1, 0}, |
|||
{ XK_Delete, XK_ANY_MOD, "\033[3~", +1, 0}, |
|||
{ XK_BackSpace, XK_NO_MOD, "\177", 0, 0}, |
|||
{ XK_BackSpace, Mod1Mask, "\033\177", 0, 0}, |
|||
{ XK_Home, ShiftMask, "\033[2J", 0, -1}, |
|||
{ XK_Home, ShiftMask, "\033[1;2H", 0, +1}, |
|||
{ XK_Home, XK_ANY_MOD, "\033[H", 0, -1}, |
|||
{ XK_Home, XK_ANY_MOD, "\033[1~", 0, +1}, |
|||
{ XK_End, ControlMask, "\033[J", -1, 0}, |
|||
{ XK_End, ControlMask, "\033[1;5F", +1, 0}, |
|||
{ XK_End, ShiftMask, "\033[K", -1, 0}, |
|||
{ XK_End, ShiftMask, "\033[1;2F", +1, 0}, |
|||
{ XK_End, XK_ANY_MOD, "\033[4~", 0, 0}, |
|||
{ XK_Prior, ControlMask, "\033[5;5~", 0, 0}, |
|||
{ XK_Prior, ShiftMask, "\033[5;2~", 0, 0}, |
|||
{ XK_Prior, XK_ANY_MOD, "\033[5~", 0, 0}, |
|||
{ XK_Next, ControlMask, "\033[6;5~", 0, 0}, |
|||
{ XK_Next, ShiftMask, "\033[6;2~", 0, 0}, |
|||
{ XK_Next, XK_ANY_MOD, "\033[6~", 0, 0}, |
|||
{ XK_F1, XK_NO_MOD, "\033OP" , 0, 0}, |
|||
{ XK_F1, /* F13 */ ShiftMask, "\033[1;2P", 0, 0}, |
|||
{ XK_F1, /* F25 */ ControlMask, "\033[1;5P", 0, 0}, |
|||
{ XK_F1, /* F37 */ Mod4Mask, "\033[1;6P", 0, 0}, |
|||
{ XK_F1, /* F49 */ Mod1Mask, "\033[1;3P", 0, 0}, |
|||
{ XK_F1, /* F61 */ Mod3Mask, "\033[1;4P", 0, 0}, |
|||
{ XK_F2, XK_NO_MOD, "\033OQ" , 0, 0}, |
|||
{ XK_F2, /* F14 */ ShiftMask, "\033[1;2Q", 0, 0}, |
|||
{ XK_F2, /* F26 */ ControlMask, "\033[1;5Q", 0, 0}, |
|||
{ XK_F2, /* F38 */ Mod4Mask, "\033[1;6Q", 0, 0}, |
|||
{ XK_F2, /* F50 */ Mod1Mask, "\033[1;3Q", 0, 0}, |
|||
{ XK_F2, /* F62 */ Mod3Mask, "\033[1;4Q", 0, 0}, |
|||
{ XK_F3, XK_NO_MOD, "\033OR" , 0, 0}, |
|||
{ XK_F3, /* F15 */ ShiftMask, "\033[1;2R", 0, 0}, |
|||
{ XK_F3, /* F27 */ ControlMask, "\033[1;5R", 0, 0}, |
|||
{ XK_F3, /* F39 */ Mod4Mask, "\033[1;6R", 0, 0}, |
|||
{ XK_F3, /* F51 */ Mod1Mask, "\033[1;3R", 0, 0}, |
|||
{ XK_F3, /* F63 */ Mod3Mask, "\033[1;4R", 0, 0}, |
|||
{ XK_F4, XK_NO_MOD, "\033OS" , 0, 0}, |
|||
{ XK_F4, /* F16 */ ShiftMask, "\033[1;2S", 0, 0}, |
|||
{ XK_F4, /* F28 */ ControlMask, "\033[1;5S", 0, 0}, |
|||
{ XK_F4, /* F40 */ Mod4Mask, "\033[1;6S", 0, 0}, |
|||
{ XK_F4, /* F52 */ Mod1Mask, "\033[1;3S", 0, 0}, |
|||
{ XK_F5, XK_NO_MOD, "\033[15~", 0, 0}, |
|||
{ XK_F5, /* F17 */ ShiftMask, "\033[15;2~", 0, 0}, |
|||
{ XK_F5, /* F29 */ ControlMask, "\033[15;5~", 0, 0}, |
|||
{ XK_F5, /* F41 */ Mod4Mask, "\033[15;6~", 0, 0}, |
|||
{ XK_F5, /* F53 */ Mod1Mask, "\033[15;3~", 0, 0}, |
|||
{ XK_F6, XK_NO_MOD, "\033[17~", 0, 0}, |
|||
{ XK_F6, /* F18 */ ShiftMask, "\033[17;2~", 0, 0}, |
|||
{ XK_F6, /* F30 */ ControlMask, "\033[17;5~", 0, 0}, |
|||
{ XK_F6, /* F42 */ Mod4Mask, "\033[17;6~", 0, 0}, |
|||
{ XK_F6, /* F54 */ Mod1Mask, "\033[17;3~", 0, 0}, |
|||
{ XK_F7, XK_NO_MOD, "\033[18~", 0, 0}, |
|||
{ XK_F7, /* F19 */ ShiftMask, "\033[18;2~", 0, 0}, |
|||
{ XK_F7, /* F31 */ ControlMask, "\033[18;5~", 0, 0}, |
|||
{ XK_F7, /* F43 */ Mod4Mask, "\033[18;6~", 0, 0}, |
|||
{ XK_F7, /* F55 */ Mod1Mask, "\033[18;3~", 0, 0}, |
|||
{ XK_F8, XK_NO_MOD, "\033[19~", 0, 0}, |
|||
{ XK_F8, /* F20 */ ShiftMask, "\033[19;2~", 0, 0}, |
|||
{ XK_F8, /* F32 */ ControlMask, "\033[19;5~", 0, 0}, |
|||
{ XK_F8, /* F44 */ Mod4Mask, "\033[19;6~", 0, 0}, |
|||
{ XK_F8, /* F56 */ Mod1Mask, "\033[19;3~", 0, 0}, |
|||
{ XK_F9, XK_NO_MOD, "\033[20~", 0, 0}, |
|||
{ XK_F9, /* F21 */ ShiftMask, "\033[20;2~", 0, 0}, |
|||
{ XK_F9, /* F33 */ ControlMask, "\033[20;5~", 0, 0}, |
|||
{ XK_F9, /* F45 */ Mod4Mask, "\033[20;6~", 0, 0}, |
|||
{ XK_F9, /* F57 */ Mod1Mask, "\033[20;3~", 0, 0}, |
|||
{ XK_F10, XK_NO_MOD, "\033[21~", 0, 0}, |
|||
{ XK_F10, /* F22 */ ShiftMask, "\033[21;2~", 0, 0}, |
|||
{ XK_F10, /* F34 */ ControlMask, "\033[21;5~", 0, 0}, |
|||
{ XK_F10, /* F46 */ Mod4Mask, "\033[21;6~", 0, 0}, |
|||
{ XK_F10, /* F58 */ Mod1Mask, "\033[21;3~", 0, 0}, |
|||
{ XK_F11, XK_NO_MOD, "\033[23~", 0, 0}, |
|||
{ XK_F11, /* F23 */ ShiftMask, "\033[23;2~", 0, 0}, |
|||
{ XK_F11, /* F35 */ ControlMask, "\033[23;5~", 0, 0}, |
|||
{ XK_F11, /* F47 */ Mod4Mask, "\033[23;6~", 0, 0}, |
|||
{ XK_F11, /* F59 */ Mod1Mask, "\033[23;3~", 0, 0}, |
|||
{ XK_F12, XK_NO_MOD, "\033[24~", 0, 0}, |
|||
{ XK_F12, /* F24 */ ShiftMask, "\033[24;2~", 0, 0}, |
|||
{ XK_F12, /* F36 */ ControlMask, "\033[24;5~", 0, 0}, |
|||
{ XK_F12, /* F48 */ Mod4Mask, "\033[24;6~", 0, 0}, |
|||
{ XK_F12, /* F60 */ Mod1Mask, "\033[24;3~", 0, 0}, |
|||
{ XK_F13, XK_NO_MOD, "\033[1;2P", 0, 0}, |
|||
{ XK_F14, XK_NO_MOD, "\033[1;2Q", 0, 0}, |
|||
{ XK_F15, XK_NO_MOD, "\033[1;2R", 0, 0}, |
|||
{ XK_F16, XK_NO_MOD, "\033[1;2S", 0, 0}, |
|||
{ XK_F17, XK_NO_MOD, "\033[15;2~", 0, 0}, |
|||
{ XK_F18, XK_NO_MOD, "\033[17;2~", 0, 0}, |
|||
{ XK_F19, XK_NO_MOD, "\033[18;2~", 0, 0}, |
|||
{ XK_F20, XK_NO_MOD, "\033[19;2~", 0, 0}, |
|||
{ XK_F21, XK_NO_MOD, "\033[20;2~", 0, 0}, |
|||
{ XK_F22, XK_NO_MOD, "\033[21;2~", 0, 0}, |
|||
{ XK_F23, XK_NO_MOD, "\033[23;2~", 0, 0}, |
|||
{ XK_F24, XK_NO_MOD, "\033[24;2~", 0, 0}, |
|||
{ XK_F25, XK_NO_MOD, "\033[1;5P", 0, 0}, |
|||
{ XK_F26, XK_NO_MOD, "\033[1;5Q", 0, 0}, |
|||
{ XK_F27, XK_NO_MOD, "\033[1;5R", 0, 0}, |
|||
{ XK_F28, XK_NO_MOD, "\033[1;5S", 0, 0}, |
|||
{ XK_F29, XK_NO_MOD, "\033[15;5~", 0, 0}, |
|||
{ XK_F30, XK_NO_MOD, "\033[17;5~", 0, 0}, |
|||
{ XK_F31, XK_NO_MOD, "\033[18;5~", 0, 0}, |
|||
{ XK_F32, XK_NO_MOD, "\033[19;5~", 0, 0}, |
|||
{ XK_F33, XK_NO_MOD, "\033[20;5~", 0, 0}, |
|||
{ XK_F34, XK_NO_MOD, "\033[21;5~", 0, 0}, |
|||
{ XK_F35, XK_NO_MOD, "\033[23;5~", 0, 0}, |
|||
}; |
|||
|
|||
/*
|
|||
* Selection types' masks. |
|||
* Use the same masks as usual. |
|||
* Button1Mask is always unset, to make masks match between ButtonPress. |
|||
* ButtonRelease and MotionNotify. |
|||
* If no match is found, regular selection is used. |
|||
*/ |
|||
static uint selmasks[] = { |
|||
[SEL_RECTANGULAR] = Mod1Mask, |
|||
}; |
|||
|
|||
/*
|
|||
* Printable characters in ASCII, used to estimate the advance width |
|||
* of single wide characters. |
|||
*/ |
|||
static char ascii_printable[] = |
|||
" !\"#$%&'()*+,-./0123456789:;<=>?" |
|||
"@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_" |
|||
"`abcdefghijklmnopqrstuvwxyz{|}~"; |
|||
Binary file not shown.
@ -0,0 +1,152 @@ |
|||
diff --git a/x.c b/x.c
|
|||
index 00cb6b1..8f87c0f 100644
|
|||
--- a/x.c
|
|||
+++ b/x.c
|
|||
@@ -78,6 +78,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 */ |
|||
@@ -311,7 +312,7 @@ zoomreset(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; |
|||
} |
|||
@@ -319,7 +320,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; |
|||
} |
|||
@@ -675,6 +676,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); |
|||
@@ -793,8 +797,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; |
|||
@@ -1022,8 +1026,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 + cols * win.cw;
|
|||
+ win.h = 2 * win.vborderpx + rows * win.ch;
|
|||
if (xw.gm & XNegative) |
|||
xw.l += DisplayWidth(xw.dpy, xw.scr) - win.w - 2; |
|||
if (xw.gm & YNegative) |
|||
@@ -1123,7 +1127,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; |
|||
@@ -1259,7 +1263,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; |
|||
@@ -1349,17 +1353,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.hborderpx);
|
|||
+ 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. */ |
|||
@@ -1452,35 +1456,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); |
|||
} |
|||
} |
|||
Binary file not shown.
File diff suppressed because it is too large
Binary file not shown.
Loading…
Reference in new issue