c2ny/.config-deprecated
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
c2ny
2026-03-16 01:59:49 -04:00
parent a09a4096b0
commit bba5f6794a
468 changed files with 60004 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
st-flexipatch/patch/alpha.c Normal file
View File

@@ -0,0 +1,30 @@
float
clamp(float value, float lower, float upper) {
if (value < lower)
return lower;
if (value > upper)
return upper;
return value;
}
void
changealpha(const Arg *arg)
{
if ((alpha > 0 && arg->f < 0) || (alpha < 1 && arg->f > 0))
alpha += arg->f;
alpha = clamp(alpha, 0.0, 1.0);
xloadcols();
redraw();
}
#if ALPHA_FOCUS_HIGHLIGHT_PATCH
void
changealphaunfocused(const Arg *arg)
{
if ((alphaUnfocused > 0 && arg->f < 0) || (alphaUnfocused < 1 && arg->f > 0))
alphaUnfocused += arg->f;
alphaUnfocused = clamp(alphaUnfocused, 0.0, 1.0);
xloadcols();
redraw();
}
#endif // ALPHA_FOCUS_HIGHLIGHT_PATCH

5
st-flexipatch/patch/alpha.h Normal file
View File

@@ -0,0 +1,5 @@
static float clamp(float value, float lower, float upper);
static void changealpha(const Arg *);
#if ALPHA_FOCUS_HIGHLIGHT_PATCH
static void changealphaunfocused(const Arg *arg);
#endif // ALPHA_FOCUS_HIGHLIGHT_PATCH

106
st-flexipatch/patch/background_image_x.c Normal file
View File

@@ -0,0 +1,106 @@
void
updatexy()
{
Window child;
XTranslateCoordinates(xw.dpy, xw.win, DefaultRootWindow(xw.dpy), 0, 0, &win.x, &win.y, &child);
}
/*
* load farbfeld file to XImage
*/
XImage*
loadff(const char *filename)
{
uint32_t i, hdr[4], w, h, size;
uint64_t *data;
FILE *f = fopen(filename, "rb");
if (f == NULL) {
fprintf(stderr, "could not load background image.\n");
return NULL;
}
if (fread(hdr, sizeof(*hdr), LEN(hdr), f) != LEN(hdr)) {
fprintf(stderr, "fread: %s\n", ferror(f) ? "" : "Unexpected end of file reading header");
fclose(f);
return NULL;
}
if (memcmp("farbfeld", hdr, sizeof("farbfeld") - 1)) {
fprintf(stderr, "Invalid magic value\n");
fclose(f);
return NULL;
}
w = ntohl(hdr[2]);
h = ntohl(hdr[3]);
size = w * h;
data = xmalloc(size * sizeof(uint64_t));
if (fread(data, sizeof(uint64_t), size, f) != size) {
fprintf(stderr, "fread: %s\n", ferror(f) ? "" : "Unexpected end of file reading data");
fclose(f);
return NULL;
}
fclose(f);
for (i = 0; i < size; i++)
data[i] = (data[i] & 0x00000000000000FF) << 16 |
(data[i] & 0x0000000000FF0000) >> 8 |
(data[i] & 0x000000FF00000000) >> 32 |
(data[i] & 0x00FF000000000000) >> 24;
#if ALPHA_PATCH
XImage *xi = XCreateImage(xw.dpy, xw.vis, xw.depth, ZPixmap, 0,
(char *)data, w, h, 32, w * 8);
#else
XImage *xi = XCreateImage(xw.dpy, DefaultVisual(xw.dpy, xw.scr),
DefaultDepth(xw.dpy, xw.scr), ZPixmap, 0,
(char *)data, w, h, 32, w * 8);
#endif // ALPHA_PATCH
xi->bits_per_pixel = 64;
return xi;
}
/*
* initialize background image
*/
void
bginit()
{
XGCValues gcvalues;
Drawable bgimg;
XImage *bgxi = loadff(bgfile);
memset(&gcvalues, 0, sizeof(gcvalues));
xw.bggc = XCreateGC(xw.dpy, xw.win, 0, &gcvalues);
if (!bgxi)
return;
#if ALPHA_PATCH
bgimg = XCreatePixmap(xw.dpy, xw.win, bgxi->width, bgxi->height,
xw.depth);
#else
bgimg = XCreatePixmap(xw.dpy, xw.win, bgxi->width, bgxi->height,
DefaultDepth(xw.dpy, xw.scr));
#endif // ALPHA_PATCH
XPutImage(xw.dpy, bgimg, dc.gc, bgxi, 0, 0, 0, 0, bgxi->width, bgxi->height);
XDestroyImage(bgxi);
XSetTile(xw.dpy, xw.bggc, bgimg);
XSetFillStyle(xw.dpy, xw.bggc, FillTiled);
if (pseudotransparency) {
updatexy();
MODBIT(xw.attrs.event_mask, 1, PropertyChangeMask);
XChangeWindowAttributes(xw.dpy, xw.win, CWEventMask, &xw.attrs);
}
}
#if BACKGROUND_IMAGE_RELOAD_PATCH
void
reload_image()
{
XFreeGC(xw.dpy, xw.bggc);
bginit();
redraw();
}
#endif // XRESOURCES_RELOAD_PATCH

6
st-flexipatch/patch/background_image_x.h Normal file
View File

@@ -0,0 +1,6 @@
#include <arpa/inet.h>
static void updatexy(void);
static XImage *loadff(const char *);
static void bginit();
static void reload_image();

192
st-flexipatch/patch/boxdraw.c Normal file
View File

@@ -0,0 +1,192 @@
/*
* Copyright 2018 Avi Halachmi (:avih) avihpit@yahoo.com https://github.com/avih
* MIT/X Consortium License
*/
#include <X11/Xft/Xft.h>
/* Rounded non-negative integers division of n / d */
#define DIV(n, d) (((n) + (d) / 2) / (d))
static Display *xdpy;
static Colormap xcmap;
static XftDraw *xd;
static Visual *xvis;
static void drawbox(int, int, int, int, XftColor *, XftColor *, ushort);
static void drawboxlines(int, int, int, int, XftColor *, ushort);
/* public API */
void
boxdraw_xinit(Display *dpy, Colormap cmap, XftDraw *draw, Visual *vis)
{
xdpy = dpy; xcmap = cmap; xd = draw, xvis = vis;
}
int
isboxdraw(Rune u)
{
Rune block = u & ~0xff;
return (boxdraw && block == 0x2500 && boxdata[(uint8_t)u]) ||
(boxdraw_braille && block == 0x2800);
}
/* the "index" is actually the entire shape data encoded as ushort */
ushort
boxdrawindex(const Glyph *g)
{
if (boxdraw_braille && (g->u & ~0xff) == 0x2800)
return BRL | (uint8_t)g->u;
if (boxdraw_bold && (g->mode & ATTR_BOLD))
return BDB | boxdata[(uint8_t)g->u];
return boxdata[(uint8_t)g->u];
}
void
drawboxes(int x, int y, int cw, int ch, XftColor *fg, XftColor *bg,
const XftGlyphFontSpec *specs, int len)
{
for ( ; len-- > 0; x += cw, specs++)
drawbox(x, y, cw, ch, fg, bg, (ushort)specs->glyph);
}
/* implementation */
void
drawbox(int x, int y, int w, int h, XftColor *fg, XftColor *bg, ushort bd)
{
ushort cat = bd & ~(BDB | 0xff); /* mask out bold and data */
if (bd & (BDL | BDA)) {
/* lines (light/double/heavy/arcs) */
drawboxlines(x, y, w, h, fg, bd);
} else if (cat == BBD) {
/* lower (8-X)/8 block */
int d = DIV((uint8_t)bd * h, 8);
XftDrawRect(xd, fg, x, y + d, w, h - d);
} else if (cat == BBU) {
/* upper X/8 block */
XftDrawRect(xd, fg, x, y, w, DIV((uint8_t)bd * h, 8));
} else if (cat == BBL) {
/* left X/8 block */
XftDrawRect(xd, fg, x, y, DIV((uint8_t)bd * w, 8), h);
} else if (cat == BBR) {
/* right (8-X)/8 block */
int d = DIV((uint8_t)bd * w, 8);
XftDrawRect(xd, fg, x + d, y, w - d, h);
} else if (cat == BBQ) {
/* Quadrants */
int w2 = DIV(w, 2), h2 = DIV(h, 2);
if (bd & TL)
XftDrawRect(xd, fg, x, y, w2, h2);
if (bd & TR)
XftDrawRect(xd, fg, x + w2, y, w - w2, h2);
if (bd & BL)
XftDrawRect(xd, fg, x, y + h2, w2, h - h2);
if (bd & BR)
XftDrawRect(xd, fg, x + w2, y + h2, w - w2, h - h2);
} else if (bd & BBS) {
/* Shades - data is 1/2/3 for 25%/50%/75% alpha, respectively */
int d = (uint8_t)bd;
XftColor xfc;
XRenderColor xrc = { .alpha = 0xffff };
xrc.red = DIV(fg->color.red * d + bg->color.red * (4 - d), 4);
xrc.green = DIV(fg->color.green * d + bg->color.green * (4 - d), 4);
xrc.blue = DIV(fg->color.blue * d + bg->color.blue * (4 - d), 4);
XftColorAllocValue(xdpy, xvis, xcmap, &xrc, &xfc);
XftDrawRect(xd, &xfc, x, y, w, h);
XftColorFree(xdpy, xvis, xcmap, &xfc);
} else if (cat == BRL) {
/* braille, each data bit corresponds to one dot at 2x4 grid */
int w1 = DIV(w, 2);
int h1 = DIV(h, 4), h2 = DIV(h, 2), h3 = DIV(3 * h, 4);
if (bd & 1) XftDrawRect(xd, fg, x, y, w1, h1);
if (bd & 2) XftDrawRect(xd, fg, x, y + h1, w1, h2 - h1);
if (bd & 4) XftDrawRect(xd, fg, x, y + h2, w1, h3 - h2);
if (bd & 8) XftDrawRect(xd, fg, x + w1, y, w - w1, h1);
if (bd & 16) XftDrawRect(xd, fg, x + w1, y + h1, w - w1, h2 - h1);
if (bd & 32) XftDrawRect(xd, fg, x + w1, y + h2, w - w1, h3 - h2);
if (bd & 64) XftDrawRect(xd, fg, x, y + h3, w1, h - h3);
if (bd & 128) XftDrawRect(xd, fg, x + w1, y + h3, w - w1, h - h3);
}
}
void
drawboxlines(int x, int y, int w, int h, XftColor *fg, ushort bd)
{
/* s: stem thickness. width/8 roughly matches underscore thickness. */
/* We draw bold as 1.5 * normal-stem and at least 1px thicker. */
/* doubles draw at least 3px, even when w or h < 3. bold needs 6px. */
int mwh = MIN(w, h);
int base_s = MAX(1, DIV(mwh, 8));
int bold = (bd & BDB) && mwh >= 6; /* possibly ignore boldness */
int s = bold ? MAX(base_s + 1, DIV(3 * base_s, 2)) : base_s;
int w2 = DIV(w - s, 2), h2 = DIV(h - s, 2);
/* the s-by-s square (x + w2, y + h2, s, s) is the center texel. */
/* The base length (per direction till edge) includes this square. */
int light = bd & (LL | LU | LR | LD);
int double_ = bd & (DL | DU | DR | DD);
if (light) {
/* d: additional (negative) length to not-draw the center */
/* texel - at arcs and avoid drawing inside (some) doubles */
int arc = bd & BDA;
int multi_light = light & (light - 1);
int multi_double = double_ & (double_ - 1);
/* light crosses double only at DH+LV, DV+LH (ref. shapes) */
int d = arc || (multi_double && !multi_light) ? -s : 0;
if (bd & LL)
XftDrawRect(xd, fg, x, y + h2, w2 + s + d, s);
if (bd & LU)
XftDrawRect(xd, fg, x + w2, y, s, h2 + s + d);
if (bd & LR)
XftDrawRect(xd, fg, x + w2 - d, y + h2, w - w2 + d, s);
if (bd & LD)
XftDrawRect(xd, fg, x + w2, y + h2 - d, s, h - h2 + d);
}
/* double lines - also align with light to form heavy when combined */
if (double_) {
/*
* going clockwise, for each double-ray: p is additional length
* to the single-ray nearer to the previous direction, and n to
* the next. p and n adjust from the base length to lengths
* which consider other doubles - shorter to avoid intersections
* (p, n), or longer to draw the far-corner texel (n).
*/
int dl = bd & DL, du = bd & DU, dr = bd & DR, dd = bd & DD;
if (dl) {
int p = dd ? -s : 0, n = du ? -s : dd ? s : 0;
XftDrawRect(xd, fg, x, y + h2 + s, w2 + s + p, s);
XftDrawRect(xd, fg, x, y + h2 - s, w2 + s + n, s);
}
if (du) {
int p = dl ? -s : 0, n = dr ? -s : dl ? s : 0;
XftDrawRect(xd, fg, x + w2 - s, y, s, h2 + s + p);
XftDrawRect(xd, fg, x + w2 + s, y, s, h2 + s + n);
}
if (dr) {
int p = du ? -s : 0, n = dd ? -s : du ? s : 0;
XftDrawRect(xd, fg, x + w2 - p, y + h2 - s, w - w2 + p, s);
XftDrawRect(xd, fg, x + w2 - n, y + h2 + s, w - w2 + n, s);
}
if (dd) {
int p = dr ? -s : 0, n = dl ? -s : dr ? s : 0;
XftDrawRect(xd, fg, x + w2 + s, y + h2 - p, s, h - h2 + p);
XftDrawRect(xd, fg, x + w2 - s, y + h2 - n, s, h - h2 + n);
}
}
}

214
st-flexipatch/patch/boxdraw.h Normal file
View File

@@ -0,0 +1,214 @@
/*
* Copyright 2018 Avi Halachmi (:avih) avihpit@yahoo.com https://github.com/avih
* MIT/X Consortium License
*/
/*
* U+25XX codepoints data
*
* References:
* http://www.unicode.org/charts/PDF/U2500.pdf
* http://www.unicode.org/charts/PDF/U2580.pdf
*
* Test page:
* https://github.com/GNOME/vte/blob/master/doc/boxes.txt
*/
/* Each shape is encoded as 16-bits. Higher bits are category, lower are data */
/* Categories (mutually exclusive except BDB): */
/* For convenience, BDL/BDA/BBS/BDB are 1 bit each, the rest are enums */
#define BDL (1<<8) /* Box Draw Lines (light/double/heavy) */
#define BDA (1<<9) /* Box Draw Arc (light) */
#define BBD (1<<10) /* Box Block Down (lower) X/8 */
#define BBL (2<<10) /* Box Block Left X/8 */
#define BBU (3<<10) /* Box Block Upper X/8 */
#define BBR (4<<10) /* Box Block Right X/8 */
#define BBQ (5<<10) /* Box Block Quadrants */
#define BRL (6<<10) /* Box Braille (data is lower byte of U28XX) */
#define BBS (1<<14) /* Box Block Shades */
#define BDB (1<<15) /* Box Draw is Bold */
/* (BDL/BDA) Light/Double/Heavy x Left/Up/Right/Down/Horizontal/Vertical */
/* Heavy is light+double (literally drawing light+double align to form heavy) */
#define LL (1<<0)
#define LU (1<<1)
#define LR (1<<2)
#define LD (1<<3)
#define LH (LL+LR)
#define LV (LU+LD)
#define DL (1<<4)
#define DU (1<<5)
#define DR (1<<6)
#define DD (1<<7)
#define DH (DL+DR)
#define DV (DU+DD)
#define HL (LL+DL)
#define HU (LU+DU)
#define HR (LR+DR)
#define HD (LD+DD)
#define HH (HL+HR)
#define HV (HU+HD)
/* (BBQ) Quadrants Top/Bottom x Left/Right */
#define TL (1<<0)
#define TR (1<<1)
#define BL (1<<2)
#define BR (1<<3)
/* Data for U+2500 - U+259F except dashes/diagonals */
static const unsigned short boxdata[256] = {
/* light lines */
[0x00] = BDL + LH, /* light horizontal */
[0x02] = BDL + LV, /* light vertical */
[0x0c] = BDL + LD + LR, /* light down and right */
[0x10] = BDL + LD + LL, /* light down and left */
[0x14] = BDL + LU + LR, /* light up and right */
[0x18] = BDL + LU + LL, /* light up and left */
[0x1c] = BDL + LV + LR, /* light vertical and right */
[0x24] = BDL + LV + LL, /* light vertical and left */
[0x2c] = BDL + LH + LD, /* light horizontal and down */
[0x34] = BDL + LH + LU, /* light horizontal and up */
[0x3c] = BDL + LV + LH, /* light vertical and horizontal */
[0x74] = BDL + LL, /* light left */
[0x75] = BDL + LU, /* light up */
[0x76] = BDL + LR, /* light right */
[0x77] = BDL + LD, /* light down */
/* heavy [+light] lines */
[0x01] = BDL + HH,
[0x03] = BDL + HV,
[0x0d] = BDL + HR + LD,
[0x0e] = BDL + HD + LR,
[0x0f] = BDL + HD + HR,
[0x11] = BDL + HL + LD,
[0x12] = BDL + HD + LL,
[0x13] = BDL + HD + HL,
[0x15] = BDL + HR + LU,
[0x16] = BDL + HU + LR,
[0x17] = BDL + HU + HR,
[0x19] = BDL + HL + LU,
[0x1a] = BDL + HU + LL,
[0x1b] = BDL + HU + HL,
[0x1d] = BDL + HR + LV,
[0x1e] = BDL + HU + LD + LR,
[0x1f] = BDL + HD + LR + LU,
[0x20] = BDL + HV + LR,
[0x21] = BDL + HU + HR + LD,
[0x22] = BDL + HD + HR + LU,
[0x23] = BDL + HV + HR,
[0x25] = BDL + HL + LV,
[0x26] = BDL + HU + LD + LL,
[0x27] = BDL + HD + LU + LL,
[0x28] = BDL + HV + LL,
[0x29] = BDL + HU + HL + LD,
[0x2a] = BDL + HD + HL + LU,
[0x2b] = BDL + HV + HL,
[0x2d] = BDL + HL + LD + LR,
[0x2e] = BDL + HR + LL + LD,
[0x2f] = BDL + HH + LD,
[0x30] = BDL + HD + LH,
[0x31] = BDL + HD + HL + LR,
[0x32] = BDL + HR + HD + LL,
[0x33] = BDL + HH + HD,
[0x35] = BDL + HL + LU + LR,
[0x36] = BDL + HR + LU + LL,
[0x37] = BDL + HH + LU,
[0x38] = BDL + HU + LH,
[0x39] = BDL + HU + HL + LR,
[0x3a] = BDL + HU + HR + LL,
[0x3b] = BDL + HH + HU,
[0x3d] = BDL + HL + LV + LR,
[0x3e] = BDL + HR + LV + LL,
[0x3f] = BDL + HH + LV,
[0x40] = BDL + HU + LH + LD,
[0x41] = BDL + HD + LH + LU,
[0x42] = BDL + HV + LH,
[0x43] = BDL + HU + HL + LD + LR,
[0x44] = BDL + HU + HR + LD + LL,
[0x45] = BDL + HD + HL + LU + LR,
[0x46] = BDL + HD + HR + LU + LL,
[0x47] = BDL + HH + HU + LD,
[0x48] = BDL + HH + HD + LU,
[0x49] = BDL + HV + HL + LR,
[0x4a] = BDL + HV + HR + LL,
[0x4b] = BDL + HV + HH,
[0x78] = BDL + HL,
[0x79] = BDL + HU,
[0x7a] = BDL + HR,
[0x7b] = BDL + HD,
[0x7c] = BDL + HR + LL,
[0x7d] = BDL + HD + LU,
[0x7e] = BDL + HL + LR,
[0x7f] = BDL + HU + LD,
/* double [+light] lines */
[0x50] = BDL + DH,
[0x51] = BDL + DV,
[0x52] = BDL + DR + LD,
[0x53] = BDL + DD + LR,
[0x54] = BDL + DR + DD,
[0x55] = BDL + DL + LD,
[0x56] = BDL + DD + LL,
[0x57] = BDL + DL + DD,
[0x58] = BDL + DR + LU,
[0x59] = BDL + DU + LR,
[0x5a] = BDL + DU + DR,
[0x5b] = BDL + DL + LU,
[0x5c] = BDL + DU + LL,
[0x5d] = BDL + DL + DU,
[0x5e] = BDL + DR + LV,
[0x5f] = BDL + DV + LR,
[0x60] = BDL + DV + DR,
[0x61] = BDL + DL + LV,
[0x62] = BDL + DV + LL,
[0x63] = BDL + DV + DL,
[0x64] = BDL + DH + LD,
[0x65] = BDL + DD + LH,
[0x66] = BDL + DD + DH,
[0x67] = BDL + DH + LU,
[0x68] = BDL + DU + LH,
[0x69] = BDL + DH + DU,
[0x6a] = BDL + DH + LV,
[0x6b] = BDL + DV + LH,
[0x6c] = BDL + DH + DV,
/* (light) arcs */
[0x6d] = BDA + LD + LR,
[0x6e] = BDA + LD + LL,
[0x6f] = BDA + LU + LL,
[0x70] = BDA + LU + LR,
/* Lower (Down) X/8 block (data is 8 - X) */
[0x81] = BBD + 7, [0x82] = BBD + 6, [0x83] = BBD + 5, [0x84] = BBD + 4,
[0x85] = BBD + 3, [0x86] = BBD + 2, [0x87] = BBD + 1, [0x88] = BBD + 0,
/* Left X/8 block (data is X) */
[0x89] = BBL + 7, [0x8a] = BBL + 6, [0x8b] = BBL + 5, [0x8c] = BBL + 4,
[0x8d] = BBL + 3, [0x8e] = BBL + 2, [0x8f] = BBL + 1,
/* upper 1/2 (4/8), 1/8 block (X), right 1/2, 1/8 block (8-X) */
[0x80] = BBU + 4, [0x94] = BBU + 1,
[0x90] = BBR + 4, [0x95] = BBR + 7,
/* Quadrants */
[0x96] = BBQ + BL,
[0x97] = BBQ + BR,
[0x98] = BBQ + TL,
[0x99] = BBQ + TL + BL + BR,
[0x9a] = BBQ + TL + BR,
[0x9b] = BBQ + TL + TR + BL,
[0x9c] = BBQ + TL + TR + BR,
[0x9d] = BBQ + TR,
[0x9e] = BBQ + BL + TR,
[0x9f] = BBQ + BL + TR + BR,
/* Shades, data is an alpha value in 25% units (1/4, 1/2, 3/4) */
[0x91] = BBS + 1, [0x92] = BBS + 2, [0x93] = BBS + 3,
/* U+2504 - U+250B, U+254C - U+254F: unsupported (dashes) */
/* U+2571 - U+2573: unsupported (diagonals) */
};

180
st-flexipatch/patch/copyurl.c Normal file
View File

@@ -0,0 +1,180 @@
#if COPYURL_HIGHLIGHT_SELECTED_URLS_PATCH
void
tsetcolor( int row, int start, int end, uint32_t fg, uint32_t bg )
{
int i = start;
for( ; i < end; ++i )
{
term.line[row][i].fg = fg;
term.line[row][i].bg = bg;
}
}
char *
findlastany(char *str, const char** find, size_t len)
{
char* found = NULL;
int i = 0;
for(found = str + strlen(str) - 1; found >= str; --found) {
for(i = 0; i < len; i++) {
if(strncmp(found, find[i], strlen(find[i])) == 0) {
return found;
}
}
}
return NULL;
}
/*
** Select and copy the previous url on screen (do nothing if there's no url).
**
** FIXME: doesn't handle urls that span multiple lines; will need to add support
** for multiline "getsel()" first
*/
void
copyurl(const Arg *arg) {
/* () and [] can appear in urls, but excluding them here will reduce false
* positives when figuring out where a given url ends.
*/
static char URLCHARS[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789-._~:/?#@!$&'*+,;=%";
static const char* URLSTRINGS[] = {"http://", "https://"};
/* remove highlighting from previous selection if any */
if(sel.ob.x >= 0 && sel.oe.x >= 0)
tsetcolor(sel.nb.y, sel.ob.x, sel.oe.x + 1, defaultfg, defaultbg);
int i = 0,
row = 0, /* row of current URL */
col = 0, /* column of current URL start */
startrow = 0, /* row of last occurrence */
colend = 0, /* column of last occurrence */
passes = 0; /* how many rows have been scanned */
char *linestr = calloc(term.col+1, sizeof(Rune));
char *c = NULL,
*match = NULL;
row = (sel.ob.x >= 0 && sel.nb.y > 0) ? sel.nb.y : term.bot;
LIMIT(row, term.top, term.bot);
startrow = row;
colend = (sel.ob.x >= 0 && sel.nb.y > 0) ? sel.nb.x : term.col;
LIMIT(colend, 0, term.col);
/*
** Scan from (term.bot,term.col) to (0,0) and find
** next occurrance of a URL
*/
while (passes !=term.bot + 2) {
/* Read in each column of every row until
** we hit previous occurrence of URL
*/
for (col = 0, i = 0; col < colend; ++col,++i) {
linestr[i] = term.line[row][col].u;
}
linestr[term.col] = '\0';
if ((match = findlastany(linestr, URLSTRINGS,
sizeof(URLSTRINGS)/sizeof(URLSTRINGS[0]))))
break;
if (--row < term.top)
row = term.bot;
colend = term.col;
passes++;
};
if (match) {
/* must happen before trim */
selclear();
sel.ob.x = strlen(linestr) - strlen(match);
/* trim the rest of the line from the url match */
for (c = match; *c != '\0'; ++c)
if (!strchr(URLCHARS, *c)) {
*c = '\0';
break;
}
/* highlight selection by inverting terminal colors */
tsetcolor(row, sel.ob.x, sel.ob.x + strlen( match ), defaultbg, defaultfg);
/* select and copy */
sel.mode = 1;
sel.type = SEL_REGULAR;
sel.oe.x = sel.ob.x + strlen(match)-1;
sel.ob.y = sel.oe.y = row;
selnormalize();
tsetdirt(sel.nb.y, sel.ne.y);
xsetsel(getsel());
xclipcopy();
}
free(linestr);
}
#else
/* select and copy the previous url on screen (do nothing if there's no url).
* known bug: doesn't handle urls that span multiple lines (wontfix), depends on multiline "getsel()"
* known bug: only finds first url on line (mightfix)
*/
void
copyurl(const Arg *arg) {
/* () and [] can appear in urls, but excluding them here will reduce false
* positives when figuring out where a given url ends.
*/
static char URLCHARS[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789-._~:/?#@!$&'*+,;=%";
int i, row, startrow;
char *linestr = calloc(term.col+1, sizeof(Rune));
char *c, *match = NULL;
row = (sel.ob.x >= 0 && sel.nb.y > 0) ? sel.nb.y-1 : term.bot;
LIMIT(row, term.top, term.bot);
startrow = row;
/* find the start of the last url before selection */
do {
for (i = 0; i < term.col; ++i) {
linestr[i] = term.line[row][i].u;
}
linestr[term.col] = '\0';
if ((match = strstr(linestr, "http://"))
|| (match = strstr(linestr, "https://")))
break;
if (--row < term.top)
row = term.bot;
} while (row != startrow);
if (match) {
/* must happen before trim */
selclear();
sel.ob.x = strlen(linestr) - strlen(match);
/* trim the rest of the line from the url match */
for (c = match; *c != '\0'; ++c)
if (!strchr(URLCHARS, *c)) {
*c = '\0';
break;
}
/* select and copy */
sel.mode = 1;
sel.type = SEL_REGULAR;
sel.oe.x = sel.ob.x + strlen(match)-1;
sel.ob.y = sel.oe.y = row;
selnormalize();
tsetdirt(sel.nb.y, sel.ne.y);
xsetsel(getsel());
xclipcopy();
}
free(linestr);
}
#endif // COPYURL_HIGHLIGHT_SELECTED_URLS_PATCH

5
st-flexipatch/patch/copyurl.h Normal file
View File

@@ -0,0 +1,5 @@
void copyurl(const Arg *);
#if COPYURL_HIGHLIGHT_SELECTED_URLS_PATCH
static void tsetcolor(int, int, int, uint32_t, uint32_t);
static char * findlastany(char *, const char**, size_t);
#endif // COPYURL_HIGHLIGHT_SELECTED_URLS_PATCH

204
st-flexipatch/patch/drag-n-drop.c Normal file
View File

@@ -0,0 +1,204 @@
const char XdndVersion = 5;
void
xdndsel(XEvent *e)
{
char* data;
unsigned long result;
Atom actualType;
int32_t actualFormat;
unsigned long bytesAfter;
XEvent reply = { ClientMessage };
reply.xclient.window = xw.XdndSourceWin;
reply.xclient.format = 32;
reply.xclient.data.l[0] = (long) xw.win;
reply.xclient.data.l[2] = 0;
reply.xclient.data.l[3] = 0;
XGetWindowProperty((Display*) xw.dpy, e->xselection.requestor,
e->xselection.property, 0, LONG_MAX, False,
e->xselection.target, &actualType, &actualFormat, &result,
&bytesAfter, (unsigned char**) &data);
if (result == 0)
return;
if (data) {
xdndpastedata(data);
XFree(data);
}
if (xw.XdndSourceVersion >= 2) {
reply.xclient.message_type = xw.XdndFinished;
reply.xclient.data.l[1] = result;
reply.xclient.data.l[2] = xw.XdndActionCopy;
XSendEvent((Display*) xw.dpy, xw.XdndSourceWin, False, NoEventMask,
&reply);
XFlush((Display*) xw.dpy);
}
}
int
xdndurldecode(char *src, char *dest)
{
char c;
int i = 0;
while (*src) {
if (*src == '%' && HEX_TO_INT(src[1]) != -1 && HEX_TO_INT(src[2]) != -1) {
/* handle %xx escape sequences in url e.g. %20 == ' ' */
c = (char)((HEX_TO_INT(src[1]) << 4) | HEX_TO_INT(src[2]));
src += 3;
} else {
c = *src++;
}
if (strchr(xdndescchar, c) != NULL) {
*dest++ = '\\';
i++;
}
*dest++ = c;
i++;
}
*dest++ = ' ';
*dest = '\0';
return i + 1;
}
void
xdndpastedata(char *data)
{
char *pastedata, *t;
int i = 0;
pastedata = (char *)malloc(strlen(data) * 2 + 1);
*pastedata = '\0';
t = strtok(data, "\n\r");
while(t != NULL) {
/* Remove 'file://' prefix if it exists */
if (strncmp(data, "file://", 7) == 0) {
t += 7;
}
i += xdndurldecode(t, pastedata + i);
t = strtok(NULL, "\n\r");
}
xsetsel(pastedata);
selpaste(0);
}
void
xdndenter(XEvent *e)
{
unsigned long count;
Atom* formats;
Atom real_formats[6];
Bool list;
Atom actualType;
int32_t actualFormat;
unsigned long bytesAfter;
unsigned long i;
list = e->xclient.data.l[1] & 1;
if (list) {
XGetWindowProperty((Display*) xw.dpy,
xw.XdndSourceWin,
xw.XdndTypeList,
0,
LONG_MAX,
False,
4,
&actualType,
&actualFormat,
&count,
&bytesAfter,
(unsigned char**) &formats);
} else {
count = 0;
if (e->xclient.data.l[2] != None)
real_formats[count++] = e->xclient.data.l[2];
if (e->xclient.data.l[3] != None)
real_formats[count++] = e->xclient.data.l[3];
if (e->xclient.data.l[4] != None)
real_formats[count++] = e->xclient.data.l[4];
formats = real_formats;
}
for (i = 0; i < count; i++) {
if (formats[i] == xw.XtextUriList || formats[i] == xw.XtextPlain) {
xw.XdndSourceFormat = formats[i];
break;
}
}
if (list)
XFree(formats);
}
void
xdndpos(XEvent *e)
{
const int32_t xabs = (e->xclient.data.l[2] >> 16) & 0xffff;
const int32_t yabs = (e->xclient.data.l[2]) & 0xffff;
Window dummy;
int32_t xpos, ypos;
XEvent reply = { ClientMessage };
reply.xclient.window = xw.XdndSourceWin;
reply.xclient.format = 32;
reply.xclient.data.l[0] = (long) xw.win;
reply.xclient.data.l[2] = 0;
reply.xclient.data.l[3] = 0;
XTranslateCoordinates((Display*) xw.dpy,
XDefaultRootWindow((Display*) xw.dpy),
(Window) xw.win,
xabs, yabs,
&xpos, &ypos,
&dummy);
reply.xclient.message_type = xw.XdndStatus;
if (xw.XdndSourceFormat) {
reply.xclient.data.l[1] = 1;
if (xw.XdndSourceVersion >= 2)
reply.xclient.data.l[4] = xw.XdndActionCopy;
}
XSendEvent((Display*) xw.dpy, xw.XdndSourceWin, False, NoEventMask,
&reply);
XFlush((Display*) xw.dpy);
}
void
xdnddrop(XEvent *e)
{
Time time = CurrentTime;
XEvent reply = { ClientMessage };
reply.xclient.window = xw.XdndSourceWin;
reply.xclient.format = 32;
reply.xclient.data.l[0] = (long) xw.win;
reply.xclient.data.l[2] = 0;
reply.xclient.data.l[3] = 0;
if (xw.XdndSourceFormat) {
if (xw.XdndSourceVersion >= 1)
time = e->xclient.data.l[2];
XConvertSelection((Display*) xw.dpy, xw.XdndSelection,
xw.XdndSourceFormat, xw.XdndSelection, (Window) xw.win, time);
} else if (xw.XdndSourceVersion >= 2) {
reply.xclient.message_type = xw.XdndFinished;
XSendEvent((Display*) xw.dpy, xw.XdndSourceWin,
False, NoEventMask, &reply);
XFlush((Display*) xw.dpy);
}
}

5
st-flexipatch/patch/drag-n-drop.h Normal file
View File

@@ -0,0 +1,5 @@
static void xdndenter(XEvent *);
static void xdndpos(XEvent *);
static void xdnddrop(XEvent *);
static void xdndsel(XEvent *);
static void xdndpastedata(char *);

77
st-flexipatch/patch/externalpipe.c Normal file
View File

@@ -0,0 +1,77 @@
void
#if EXTERNALPIPEIN_PATCH
extpipe(const Arg *arg, int in)
#else
externalpipe(const Arg *arg)
#endif // EXTERNALPIPEIN_PATCH
{
int to[2];
char buf[UTF_SIZ];
void (*oldsigpipe)(int);
Glyph *bp, *end;
int lastpos, n, newline;
if (pipe(to) == -1)
return;
switch (fork()) {
case -1:
close(to[0]);
close(to[1]);
return;
case 0:
dup2(to[0], STDIN_FILENO);
close(to[0]);
close(to[1]);
#if EXTERNALPIPEIN_PATCH
if (in)
dup2(csdfd, STDOUT_FILENO);
close(csdfd);
#endif // EXTERNALPIPEIN_PATCH
execvp(((char **)arg->v)[0], (char **)arg->v);
fprintf(stderr, "st: execvp %s\n", ((char **)arg->v)[0]);
perror("failed");
exit(0);
}
close(to[0]);
/* ignore sigpipe for now, in case child exists early */
oldsigpipe = signal(SIGPIPE, SIG_IGN);
newline = 0;
for (n = 0; n < term.row; n++) {
bp = term.line[n];
#if REFLOW_PATCH
lastpos = MIN(tlinelen(TLINE(n)) + 1, term.col) - 1;
#else
lastpos = MIN(tlinelen(n) + 1, term.col) - 1;
#endif // REFLOW_PATCH
if (lastpos < 0)
break;
end = &bp[lastpos + 1];
for (; bp < end; ++bp)
if (xwrite(to[1], buf, utf8encode(bp->u, buf)) < 0)
break;
if ((newline = term.line[n][lastpos].mode & ATTR_WRAP))
continue;
if (xwrite(to[1], "\n", 1) < 0)
break;
newline = 0;
}
if (newline)
(void)xwrite(to[1], "\n", 1);
close(to[1]);
/* restore */
signal(SIGPIPE, oldsigpipe);
}
#if EXTERNALPIPEIN_PATCH
void
externalpipe(const Arg *arg) {
extpipe(arg, 0);
}
void
externalpipein(const Arg *arg) {
extpipe(arg, 1);
}
#endif // EXTERNALPIPEIN_PATCH

4
st-flexipatch/patch/externalpipe.h Normal file
View File

@@ -0,0 +1,4 @@
void externalpipe(const Arg *);
#if EXTERNALPIPEIN_PATCH
void externalpipein(const Arg *);
#endif // EXTERNALPIPEIN_PATCH

811
st-flexipatch/patch/fixkeyboardinput.c Normal file
View File

@@ -0,0 +1,811 @@
/*
* If you want keys other than the X11 function keys (0xFD00 - 0xFFFF)
* to be mapped below, add them to this array.
*/
static KeySym mappedkeys[] = {
XK_space,
XK_m,
XK_i,
XK_A,
XK_B,
XK_C,
XK_D,
XK_E,
XK_F,
XK_G,
XK_H,
XK_I,
XK_K,
XK_J,
XK_L,
XK_M,
XK_N,
XK_O,
XK_P,
XK_Q,
XK_R,
XK_S,
XK_T,
XK_U,
XK_V,
XK_W,
XK_X,
XK_Y,
XK_Z,
XK_0,
XK_1,
XK_2,
XK_3,
XK_4,
XK_5,
XK_6,
XK_7,
XK_8,
XK_9,
XK_exclam,
XK_quotedbl,
XK_numbersign,
XK_dollar,
XK_percent,
XK_ampersand,
XK_apostrophe,
XK_parenleft,
XK_parenright,
XK_asterisk,
XK_plus,
XK_comma,
XK_minus,
XK_period,
XK_slash,
XK_colon,
XK_semicolon,
XK_less,
XK_equal,
XK_greater,
XK_question,
XK_at,
XK_bracketleft,
XK_backslash,
XK_bracketright,
XK_asciicircum,
XK_underscore,
XK_grave,
XK_braceleft,
XK_bar,
XK_braceright,
XK_asciitilde,
};
/*
* 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_Prior, ShiftMask, "\033[5;2~", 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_Next, ShiftMask, "\033[6;2~", 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_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_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_NO_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_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_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_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_Prior, ControlMask, "\033[5;5~", 0, 0},
{ XK_Prior, ShiftMask, "\033[5;2~", 0, 0},
{ XK_Next, ControlMask, "\033[6;5~", 0, 0},
{ XK_Next, ShiftMask, "\033[6;2~", 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},
// libtermkey compatible keyboard input
{ XK_KP_Home, XK_NO_MOD, "\033[H", 0, -1},
{ XK_KP_Home, XK_NO_MOD, "\033[1~", 0, +1},
{ XK_KP_Home, ControlMask, "\033[149;5u", 0, 0},
{ XK_KP_Home, ControlMask|ShiftMask, "\033[149;6u", 0, 0},
{ XK_KP_Home, Mod1Mask, "\033[149;3u", 0, 0},
{ XK_KP_Home, Mod1Mask|ControlMask, "\033[149;7u", 0, 0},
{ XK_KP_Home, Mod1Mask|ControlMask|ShiftMask, "\033[149;8u", 0, 0},
{ XK_KP_Home, Mod1Mask|ShiftMask, "\033[149;4u", 0, 0},
{ XK_KP_Home, ShiftMask, "\033[149;2u", 0, 0},
{ XK_KP_Up, XK_NO_MOD, "\033Ox", +1, 0},
{ XK_KP_Up, XK_NO_MOD, "\033[A", 0, -1},
{ XK_KP_Up, XK_NO_MOD, "\033OA", 0, +1},
{ XK_KP_Up, ControlMask, "\033[151;5u", 0, 0},
{ XK_KP_Up, ControlMask|ShiftMask, "\033[151;6u", 0, 0},
{ XK_KP_Up, Mod1Mask, "\033[151;3u", 0, 0},
{ XK_KP_Up, Mod1Mask|ControlMask, "\033[151;7u", 0, 0},
{ XK_KP_Up, Mod1Mask|ControlMask|ShiftMask, "\033[151;8u", 0, 0},
{ XK_KP_Up, Mod1Mask|ShiftMask, "\033[151;4u", 0, 0},
{ XK_KP_Up, ShiftMask, "\033[151;2u", 0, 0},
{ XK_KP_Down, XK_NO_MOD, "\033Or", +1, 0},
{ XK_KP_Down, XK_NO_MOD, "\033[B", 0, -1},
{ XK_KP_Down, XK_NO_MOD, "\033OB", 0, +1},
{ XK_KP_Down, ControlMask, "\033[153;5u", 0, 0},
{ XK_KP_Down, ControlMask|ShiftMask, "\033[153;6u", 0, 0},
{ XK_KP_Down, Mod1Mask, "\033[153;3u", 0, 0},
{ XK_KP_Down, Mod1Mask|ControlMask, "\033[153;7u", 0, 0},
{ XK_KP_Down, Mod1Mask|ControlMask|ShiftMask, "\033[153;8u", 0, 0},
{ XK_KP_Down, Mod1Mask|ShiftMask, "\033[153;4u", 0, 0},
{ XK_KP_Down, ShiftMask, "\033[153;2u", 0, 0},
{ XK_KP_Left, XK_NO_MOD, "\033Ot", +1, 0},
{ XK_KP_Left, XK_NO_MOD, "\033[D", 0, -1},
{ XK_KP_Left, XK_NO_MOD, "\033OD", 0, +1},
{ XK_KP_Left, ControlMask, "\033[150;5u", 0, 0},
{ XK_KP_Left, ControlMask|ShiftMask, "\033[150;6u", 0, 0},
{ XK_KP_Left, Mod1Mask, "\033[150;3u", 0, 0},
{ XK_KP_Left, Mod1Mask|ControlMask, "\033[150;7u", 0, 0},
{ XK_KP_Left, Mod1Mask|ControlMask|ShiftMask, "\033[150;8u", 0, 0},
{ XK_KP_Left, Mod1Mask|ShiftMask, "\033[150;4u", 0, 0},
{ XK_KP_Left, ShiftMask, "\033[150;2u", 0, 0},
{ XK_KP_Right, XK_NO_MOD, "\033Ov", +1, 0},
{ XK_KP_Right, XK_NO_MOD, "\033[C", 0, -1},
{ XK_KP_Right, XK_NO_MOD, "\033OC", 0, +1},
{ XK_KP_Right, ControlMask, "\033[152;5u", 0, 0},
{ XK_KP_Right, ControlMask|ShiftMask, "\033[152;6u", 0, 0},
{ XK_KP_Right, Mod1Mask, "\033[152;3u", 0, 0},
{ XK_KP_Right, Mod1Mask|ControlMask, "\033[152;7u", 0, 0},
{ XK_KP_Right, Mod1Mask|ControlMask|ShiftMask, "\033[152;8u", 0, 0},
{ XK_KP_Right, Mod1Mask|ShiftMask, "\033[152;4u", 0, 0},
{ XK_KP_Right, ShiftMask, "\033[152;2u", 0, 0},
{ XK_KP_Prior, XK_NO_MOD, "\033[5~", 0, 0},
{ XK_KP_Prior, ControlMask, "\033[154;5u", 0, 0},
{ XK_KP_Prior, ControlMask|ShiftMask, "\033[154;6u", 0, 0},
{ XK_KP_Prior, Mod1Mask, "\033[154;3u", 0, 0},
{ XK_KP_Prior, Mod1Mask|ControlMask, "\033[154;7u", 0, 0},
{ XK_KP_Prior, Mod1Mask|ControlMask|ShiftMask, "\033[154;8u", 0, 0},
{ XK_KP_Prior, Mod1Mask|ShiftMask, "\033[154;4u", 0, 0},
{ XK_KP_Begin, XK_NO_MOD, "\033[E", 0, 0},
{ XK_KP_Begin, ControlMask, "\033[157;5u", 0, 0},
{ XK_KP_Begin, ControlMask|ShiftMask, "\033[157;6u", 0, 0},
{ XK_KP_Begin, Mod1Mask, "\033[157;3u", 0, 0},
{ XK_KP_Begin, Mod1Mask|ControlMask, "\033[157;7u", 0, 0},
{ XK_KP_Begin, Mod1Mask|ControlMask|ShiftMask, "\033[157;8u", 0, 0},
{ XK_KP_Begin, Mod1Mask|ShiftMask, "\033[157;4u", 0, 0},
{ XK_KP_Begin, ShiftMask, "\033[157;2u", 0, 0},
{ XK_KP_End, XK_NO_MOD, "\033[4~", 0, 0},
{ XK_KP_End, ControlMask|ShiftMask, "\033[156;6u", 0, 0},
{ XK_KP_End, Mod1Mask, "\033[156;3u", 0, 0},
{ XK_KP_End, Mod1Mask|ControlMask, "\033[156;7u", 0, 0},
{ XK_KP_End, Mod1Mask|ControlMask|ShiftMask, "\033[156;8u", 0, 0},
{ XK_KP_End, Mod1Mask|ShiftMask, "\033[156;4u", 0, 0},
{ XK_KP_Next, XK_NO_MOD, "\033[6~", 0, 0},
{ XK_KP_Next, ControlMask, "\033[155;5u", 0, 0},
{ XK_KP_Next, ControlMask|ShiftMask, "\033[155;6u", 0, 0},
{ XK_KP_Next, Mod1Mask, "\033[155;3u", 0, 0},
{ XK_KP_Next, Mod1Mask|ControlMask, "\033[155;7u", 0, 0},
{ XK_KP_Next, Mod1Mask|ControlMask|ShiftMask, "\033[155;8u", 0, 0},
{ XK_KP_Next, Mod1Mask|ShiftMask, "\033[155;4u", 0, 0},
{ XK_KP_Insert, XK_NO_MOD, "\033[4h", -1, 0},
{ XK_KP_Insert, XK_NO_MOD, "\033[2~", +1, 0},
{ XK_KP_Insert, ControlMask|ShiftMask, "\033[158;6u", 0, 0},
{ XK_KP_Insert, Mod1Mask, "\033[158;3u", 0, 0},
{ XK_KP_Insert, Mod1Mask|ControlMask, "\033[158;7u", 0, 0},
{ XK_KP_Insert, Mod1Mask|ControlMask|ShiftMask, "\033[158;8u", 0, 0},
{ XK_KP_Insert, Mod1Mask|ShiftMask, "\033[158;4u", 0, 0},
{ XK_KP_Delete, XK_NO_MOD, "\033[P", -1, 0},
{ XK_KP_Delete, XK_NO_MOD, "\033[3~", +1, 0},
{ XK_KP_Delete, ControlMask|ShiftMask, "\033[159;6u", 0, 0},
{ XK_KP_Delete, Mod1Mask, "\033[159;3u", 0, 0},
{ XK_KP_Delete, Mod1Mask|ControlMask, "\033[159;7u", 0, 0},
{ XK_KP_Delete, Mod1Mask|ControlMask|ShiftMask, "\033[159;8u", 0, 0},
{ XK_KP_Delete, Mod1Mask|ShiftMask, "\033[159;4u", 0, 0},
{ XK_KP_Multiply, XK_NO_MOD, "\033Oj", +2, 0},
{ XK_KP_Multiply, ControlMask, "\033[170;5u", 0, 0},
{ XK_KP_Multiply, ControlMask|ShiftMask, "\033[170;6u", 0, 0},
{ XK_KP_Multiply, Mod1Mask, "\033[170;3u", 0, 0},
{ XK_KP_Multiply, Mod1Mask|ControlMask, "\033[170;7u", 0, 0},
{ XK_KP_Multiply, Mod1Mask|ControlMask|ShiftMask, "\033[170;8u", 0, 0},
{ XK_KP_Multiply, Mod1Mask|ShiftMask, "\033[170;4u", 0, 0},
{ XK_KP_Multiply, ShiftMask, "\033[170;2u", 0, 0},
{ XK_KP_Add, XK_NO_MOD, "\033Ok", +2, 0},
{ XK_KP_Add, ControlMask, "\033[171;5u", 0, 0},
{ XK_KP_Add, ControlMask|ShiftMask, "\033[171;6u", 0, 0},
{ XK_KP_Add, Mod1Mask, "\033[171;3u", 0, 0},
{ XK_KP_Add, Mod1Mask|ControlMask, "\033[171;7u", 0, 0},
{ XK_KP_Add, Mod1Mask|ControlMask|ShiftMask, "\033[171;8u", 0, 0},
{ XK_KP_Add, Mod1Mask|ShiftMask, "\033[171;4u", 0, 0},
{ XK_KP_Add, ShiftMask, "\033[171;2u", 0, 0},
{ XK_KP_Enter, XK_NO_MOD, "\033OM", +2, 0},
{ XK_KP_Enter, XK_NO_MOD, "\r", -1, 0},
{ XK_KP_Enter, XK_NO_MOD, "\r\n", -1, 0},
{ XK_KP_Enter, ControlMask, "\033[141;5u", 0, 0},
{ XK_KP_Enter, ControlMask|ShiftMask, "\033[141;6u", 0, 0},
{ XK_KP_Enter, Mod1Mask, "\033[141;3u", 0, 0},
{ XK_KP_Enter, Mod1Mask|ControlMask, "\033[141;7u", 0, 0},
{ XK_KP_Enter, Mod1Mask|ControlMask|ShiftMask, "\033[141;8u", 0, 0},
{ XK_KP_Enter, Mod1Mask|ShiftMask, "\033[141;4u", 0, 0},
{ XK_KP_Enter, ShiftMask, "\033[141;2u", 0, 0},
{ XK_KP_Subtract, XK_NO_MOD, "\033Om", +2, 0},
{ XK_KP_Subtract, ControlMask, "\033[173;5u", 0, 0},
{ XK_KP_Subtract, ControlMask|ShiftMask, "\033[173;6u", 0, 0},
{ XK_KP_Subtract, Mod1Mask, "\033[173;3u", 0, 0},
{ XK_KP_Subtract, Mod1Mask|ControlMask, "\033[173;7u", 0, 0},
{ XK_KP_Subtract, Mod1Mask|ControlMask|ShiftMask, "\033[173;8u", 0, 0},
{ XK_KP_Subtract, Mod1Mask|ShiftMask, "\033[173;4u", 0, 0},
{ XK_KP_Subtract, ShiftMask, "\033[173;2u", 0, 0},
{ XK_KP_Decimal, XK_NO_MOD, "\033On", +2, 0},
{ XK_KP_Decimal, ControlMask, "\033[174;5u", 0, 0},
{ XK_KP_Decimal, ControlMask|ShiftMask, "\033[174;6u", 0, 0},
{ XK_KP_Decimal, Mod1Mask, "\033[174;3u", 0, 0},
{ XK_KP_Decimal, Mod1Mask|ControlMask, "\033[174;7u", 0, 0},
{ XK_KP_Decimal, Mod1Mask|ControlMask|ShiftMask, "\033[174;8u", 0, 0},
{ XK_KP_Decimal, Mod1Mask|ShiftMask, "\033[174;4u", 0, 0},
{ XK_KP_Decimal, ShiftMask, "\033[174;2u", 0, 0},
{ XK_KP_Divide, XK_NO_MOD, "\033Oo", +2, 0},
{ XK_KP_Divide, ControlMask, "\033[175;5u", 0, 0},
{ XK_KP_Divide, ControlMask|ShiftMask, "\033[175;6u", 0, 0},
{ XK_KP_Divide, Mod1Mask, "\033[175;3u", 0, 0},
{ XK_KP_Divide, Mod1Mask|ControlMask, "\033[175;7u", 0, 0},
{ XK_KP_Divide, Mod1Mask|ControlMask|ShiftMask, "\033[175;8u", 0, 0},
{ XK_KP_Divide, Mod1Mask|ShiftMask, "\033[175;4u", 0, 0},
{ XK_KP_Divide, ShiftMask, "\033[175;2u", 0, 0},
{ XK_KP_0, XK_NO_MOD, "\033Op", +2, 0},
{ XK_KP_0, ControlMask, "\033[176;5u", 0, 0},
{ XK_KP_0, ControlMask|ShiftMask, "\033[176;6u", 0, 0},
{ XK_KP_0, Mod1Mask, "\033[176;3u", 0, 0},
{ XK_KP_0, Mod1Mask|ControlMask, "\033[176;7u", 0, 0},
{ XK_KP_0, Mod1Mask|ControlMask|ShiftMask, "\033[176;8u", 0, 0},
{ XK_KP_0, Mod1Mask|ShiftMask, "\033[176;4u", 0, 0},
{ XK_KP_0, ShiftMask, "\033[176;2u", 0, 0},
{ XK_KP_1, XK_NO_MOD, "\033Oq", +2, 0},
{ XK_KP_0, ControlMask, "\033[177;5u", 0, 0},
{ XK_KP_0, ControlMask|ShiftMask, "\033[177;6u", 0, 0},
{ XK_KP_0, Mod1Mask, "\033[177;3u", 0, 0},
{ XK_KP_0, Mod1Mask|ControlMask, "\033[177;7u", 0, 0},
{ XK_KP_0, Mod1Mask|ControlMask|ShiftMask, "\033[177;8u", 0, 0},
{ XK_KP_0, Mod1Mask|ShiftMask, "\033[177;4u", 0, 0},
{ XK_KP_0, ShiftMask, "\033[177;2u", 0, 0},
{ XK_KP_2, XK_NO_MOD, "\033Or", +2, 0},
{ XK_KP_2, ControlMask, "\033[178;5u", 0, 0},
{ XK_KP_2, ControlMask|ShiftMask, "\033[178;6u", 0, 0},
{ XK_KP_2, Mod1Mask, "\033[178;3u", 0, 0},
{ XK_KP_2, Mod1Mask|ControlMask, "\033[178;7u", 0, 0},
{ XK_KP_2, Mod1Mask|ControlMask|ShiftMask, "\033[178;8u", 0, 0},
{ XK_KP_2, Mod1Mask|ShiftMask, "\033[178;4u", 0, 0},
{ XK_KP_2, ShiftMask, "\033[178;2u", 0, 0},
{ XK_KP_3, XK_NO_MOD, "\033Os", +2, 0},
{ XK_KP_3, ControlMask, "\033[179;5u", 0, 0},
{ XK_KP_3, ControlMask|ShiftMask, "\033[179;6u", 0, 0},
{ XK_KP_3, Mod1Mask, "\033[179;3u", 0, 0},
{ XK_KP_3, Mod1Mask|ControlMask, "\033[179;7u", 0, 0},
{ XK_KP_3, Mod1Mask|ControlMask|ShiftMask, "\033[179;8u", 0, 0},
{ XK_KP_3, Mod1Mask|ShiftMask, "\033[179;4u", 0, 0},
{ XK_KP_3, ShiftMask, "\033[179;2u", 0, 0},
{ XK_KP_4, XK_NO_MOD, "\033Ot", +2, 0},
{ XK_KP_4, ControlMask, "\033[180;5u", 0, 0},
{ XK_KP_4, ControlMask|ShiftMask, "\033[180;6u", 0, 0},
{ XK_KP_4, Mod1Mask, "\033[180;3u", 0, 0},
{ XK_KP_4, Mod1Mask|ControlMask, "\033[180;7u", 0, 0},
{ XK_KP_4, Mod1Mask|ControlMask|ShiftMask, "\033[180;8u", 0, 0},
{ XK_KP_4, Mod1Mask|ShiftMask, "\033[180;4u", 0, 0},
{ XK_KP_4, ShiftMask, "\033[180;2u", 0, 0},
{ XK_KP_5, XK_NO_MOD, "\033Ou", +2, 0},
{ XK_KP_5, ControlMask, "\033[181;5u", 0, 0},
{ XK_KP_5, ControlMask|ShiftMask, "\033[181;6u", 0, 0},
{ XK_KP_5, Mod1Mask, "\033[181;3u", 0, 0},
{ XK_KP_5, Mod1Mask|ControlMask, "\033[181;7u", 0, 0},
{ XK_KP_5, Mod1Mask|ControlMask|ShiftMask, "\033[181;8u", 0, 0},
{ XK_KP_5, Mod1Mask|ShiftMask, "\033[181;4u", 0, 0},
{ XK_KP_5, ShiftMask, "\033[181;2u", 0, 0},
{ XK_KP_6, XK_NO_MOD, "\033Ov", +2, 0},
{ XK_KP_6, ControlMask, "\033[182;5u", 0, 0},
{ XK_KP_6, ControlMask|ShiftMask, "\033[182;6u", 0, 0},
{ XK_KP_6, Mod1Mask, "\033[182;3u", 0, 0},
{ XK_KP_6, Mod1Mask|ControlMask, "\033[182;7u", 0, 0},
{ XK_KP_6, Mod1Mask|ControlMask|ShiftMask, "\033[182;8u", 0, 0},
{ XK_KP_6, Mod1Mask|ShiftMask, "\033[182;4u", 0, 0},
{ XK_KP_6, ShiftMask, "\033[182;2u", 0, 0},
{ XK_KP_7, XK_NO_MOD, "\033Ow", +2, 0},
{ XK_KP_7, ControlMask, "\033[183;5u", 0, 0},
{ XK_KP_7, ControlMask|ShiftMask, "\033[183;6u", 0, 0},
{ XK_KP_7, Mod1Mask, "\033[183;3u", 0, 0},
{ XK_KP_7, Mod1Mask|ControlMask, "\033[183;7u", 0, 0},
{ XK_KP_7, Mod1Mask|ControlMask|ShiftMask, "\033[183;8u", 0, 0},
{ XK_KP_7, Mod1Mask|ShiftMask, "\033[183;4u", 0, 0},
{ XK_KP_7, ShiftMask, "\033[183;2u", 0, 0},
{ XK_KP_8, XK_NO_MOD, "\033Ox", +2, 0},
{ XK_KP_8, ControlMask, "\033[184;5u", 0, 0},
{ XK_KP_8, ControlMask|ShiftMask, "\033[184;6u", 0, 0},
{ XK_KP_8, Mod1Mask, "\033[184;3u", 0, 0},
{ XK_KP_8, Mod1Mask|ControlMask, "\033[184;7u", 0, 0},
{ XK_KP_8, Mod1Mask|ControlMask|ShiftMask, "\033[184;8u", 0, 0},
{ XK_KP_8, Mod1Mask|ShiftMask, "\033[184;4u", 0, 0},
{ XK_KP_8, ShiftMask, "\033[184;2u", 0, 0},
{ XK_KP_9, XK_NO_MOD, "\033Oy", +2, 0},
{ XK_KP_9, ControlMask, "\033[185;5u", 0, 0},
{ XK_KP_9, ControlMask|ShiftMask, "\033[185;6u", 0, 0},
{ XK_KP_9, Mod1Mask, "\033[185;3u", 0, 0},
{ XK_KP_9, Mod1Mask|ControlMask, "\033[185;7u", 0, 0},
{ XK_KP_9, Mod1Mask|ControlMask|ShiftMask, "\033[185;8u", 0, 0},
{ XK_KP_9, Mod1Mask|ShiftMask, "\033[185;4u", 0, 0},
{ XK_KP_9, ShiftMask, "\033[185;2u", 0, 0},
{ XK_BackSpace, ControlMask, "\033[127;5u", 0, 0},
{ XK_BackSpace, ControlMask|ShiftMask, "\033[127;6u", 0, 0},
{ XK_BackSpace, Mod1Mask, "\033[127;3u", 0, 0},
{ XK_BackSpace, Mod1Mask|ControlMask, "\033[127;7u", 0, 0},
{ XK_BackSpace, Mod1Mask|ControlMask|ShiftMask, "\033[127;8u", 0, 0},
{ XK_BackSpace, Mod1Mask|ShiftMask, "\033[127;4u", 0, 0},
{ XK_BackSpace, ShiftMask, "\033[127;2u", 0, 0},
{ XK_Tab, ControlMask, "\033[9;5u", 0, 0},
{ XK_Tab, ControlMask|ShiftMask, "\033[1;5Z", 0, 0},
{ XK_Tab, Mod1Mask, "\033[1;3Z", 0, 0},
{ XK_Tab, Mod1Mask|ControlMask, "\033[1;7Z", 0, 0},
{ XK_Tab, Mod1Mask|ControlMask|ShiftMask, "\033[1;8Z", 0, 0},
{ XK_Tab, Mod1Mask|ShiftMask, "\033[1;4Z", 0, 0},
{ XK_Return, ControlMask, "\033[13;5u", 0, 0},
{ XK_Return, ControlMask|ShiftMask, "\033[13;6u", 0, 0},
{ XK_Return, Mod1Mask, "\033[13;3u", 0, 0},
{ XK_Return, Mod1Mask|ControlMask, "\033[13;7u", 0, 0},
{ XK_Return, Mod1Mask|ControlMask|ShiftMask, "\033[13;8u", 0, 0},
{ XK_Return, Mod1Mask|ShiftMask, "\033[13;4u", 0, 0},
{ XK_Return, ShiftMask, "\033[13;2u", 0, 0},
{ XK_Pause, ControlMask, "\033[18;5u", 0, 0},
{ XK_Pause, ControlMask|ShiftMask, "\033[18;6u", 0, 0},
{ XK_Pause, Mod1Mask, "\033[18;3u", 0, 0},
{ XK_Pause, Mod1Mask|ControlMask, "\033[18;7u", 0, 0},
{ XK_Pause, Mod1Mask|ControlMask|ShiftMask, "\033[18;8u", 0, 0},
{ XK_Pause, Mod1Mask|ShiftMask, "\033[18;4u", 0, 0},
{ XK_Pause, ShiftMask, "\033[18;2u", 0, 0},
{ XK_Scroll_Lock, ControlMask, "\033[20;5u", 0, 0},
{ XK_Scroll_Lock, ControlMask|ShiftMask, "\033[20;6u", 0, 0},
{ XK_Scroll_Lock, Mod1Mask, "\033[20;3u", 0, 0},
{ XK_Scroll_Lock, Mod1Mask|ControlMask, "\033[20;7u", 0, 0},
{ XK_Scroll_Lock, Mod1Mask|ControlMask|ShiftMask, "\033[20;8u", 0, 0},
{ XK_Scroll_Lock, Mod1Mask|ShiftMask, "\033[20;4u", 0, 0},
{ XK_Scroll_Lock, ShiftMask, "\033[20;2u", 0, 0},
{ XK_Escape, ControlMask, "\033[27;5u", 0, 0},
{ XK_Escape, ControlMask|ShiftMask, "\033[27;6u", 0, 0},
{ XK_Escape, Mod1Mask, "\033[27;3u", 0, 0},
{ XK_Escape, Mod1Mask|ControlMask, "\033[27;7u", 0, 0},
{ XK_Escape, Mod1Mask|ControlMask|ShiftMask, "\033[27;8u", 0, 0},
{ XK_Escape, Mod1Mask|ShiftMask, "\033[27;4u", 0, 0},
{ XK_Escape, ShiftMask, "\033[27;2u", 0, 0},
{ XK_Home, XK_NO_MOD, "\033[H", 0, -1},
{ XK_Home, XK_NO_MOD, "\033[1~", 0, +1},
{ XK_Home, ControlMask|ShiftMask, "\033[80;6u", 0, 0},
{ XK_Home, Mod1Mask, "\033[80;3u", 0, 0},
{ XK_Home, Mod1Mask|ControlMask, "\033[80;7u", 0, 0},
{ XK_Home, Mod1Mask|ControlMask|ShiftMask, "\033[80;8u", 0, 0},
{ XK_Home, Mod1Mask|ShiftMask, "\033[80;4u", 0, 0},
{ XK_End, XK_NO_MOD, "\033[4~", 0, 0},
{ XK_End, ControlMask|ShiftMask, "\033[87;6u", 0, 0},
{ XK_End, Mod1Mask, "\033[87;3u", 0, 0},
{ XK_End, Mod1Mask|ControlMask, "\033[87;7u", 0, 0},
{ XK_End, Mod1Mask|ControlMask|ShiftMask, "\033[87;8u", 0, 0},
{ XK_End, Mod1Mask|ShiftMask, "\033[87;4u", 0, 0},
{ XK_Prior, XK_NO_MOD, "\033[5~", 0, 0},
{ XK_Prior, ControlMask|ShiftMask, "\033[85;6u", 0, 0},
{ XK_Prior, Mod1Mask, "\033[85;3u", 0, 0},
{ XK_Prior, Mod1Mask|ControlMask, "\033[85;7u", 0, 0},
{ XK_Prior, Mod1Mask|ControlMask|ShiftMask, "\033[85;8u", 0, 0},
{ XK_Prior, Mod1Mask|ShiftMask, "\033[85;4u", 0, 0},
{ XK_Next, XK_NO_MOD, "\033[6~", 0, 0},
{ XK_Next, ControlMask|ShiftMask, "\033[86;6u", 0, 0},
{ XK_Next, Mod1Mask, "\033[86;3u", 0, 0},
{ XK_Next, Mod1Mask|ControlMask, "\033[86;7u", 0, 0},
{ XK_Next, Mod1Mask|ControlMask|ShiftMask, "\033[86;8u", 0, 0},
{ XK_Next, Mod1Mask|ShiftMask, "\033[86;4u", 0, 0},
{ XK_Print, ControlMask, "\033[97;5u", 0, 0},
{ XK_Print, ControlMask|ShiftMask, "\033[97;6u", 0, 0},
{ XK_Print, Mod1Mask, "\033[97;3u", 0, 0},
{ XK_Print, Mod1Mask|ControlMask, "\033[97;7u", 0, 0},
{ XK_Print, Mod1Mask|ControlMask|ShiftMask, "\033[97;8u", 0, 0},
{ XK_Print, Mod1Mask|ShiftMask, "\033[97;4u", 0, 0},
{ XK_Print, ShiftMask, "\033[97;2u", 0, 0},
{ XK_Insert, XK_NO_MOD, "\033[4h", -1, 0},
{ XK_Insert, XK_NO_MOD, "\033[2~", +1, 0},
{ XK_Insert, ControlMask|ShiftMask, "\033[99;6u", 0, 0},
{ XK_Insert, Mod1Mask, "\033[99;3u", 0, 0},
{ XK_Insert, Mod1Mask|ControlMask, "\033[99;7u", 0, 0},
{ XK_Insert, Mod1Mask|ControlMask|ShiftMask, "\033[99;8u", 0, 0},
{ XK_Insert, Mod1Mask|ShiftMask, "\033[99;4u", 0, 0},
{ XK_Menu, ControlMask, "\033[103;5u", 0, 0},
{ XK_Menu, ControlMask|ShiftMask, "\033[103;6u", 0, 0},
{ XK_Menu, Mod1Mask, "\033[103;3u", 0, 0},
{ XK_Menu, Mod1Mask|ControlMask, "\033[103;7u", 0, 0},
{ XK_Menu, Mod1Mask|ControlMask|ShiftMask, "\033[103;8u", 0, 0},
{ XK_Menu, Mod1Mask|ShiftMask, "\033[103;4u", 0, 0},
{ XK_Menu, ShiftMask, "\033[103;2u", 0, 0},
{ XK_Delete, XK_NO_MOD, "\033[P", -1, 0},
{ XK_Delete, XK_NO_MOD, "\033[3~", +1, 0},
{ XK_Delete, ControlMask|ShiftMask, "\033[255;6u", 0, 0},
{ XK_Delete, Mod1Mask, "\033[255;3u", 0, 0},
{ XK_Delete, Mod1Mask|ControlMask, "\033[255;7u", 0, 0},
{ XK_Delete, Mod1Mask|ControlMask|ShiftMask, "\033[255;8u", 0, 0},
{ XK_Delete, Mod1Mask|ShiftMask, "\033[255;4u", 0, 0},
{ XK_i, ControlMask, "\033[105;5u", 0, 0},
{ XK_i, Mod1Mask|ControlMask, "\033[105;7u", 0, 0},
{ XK_m, ControlMask, "\033[109;5u", 0, 0},
{ XK_m, Mod1Mask|ControlMask, "\033[109;7u", 0, 0},
{ XK_space, ControlMask|ShiftMask, "\033[32;6u", 0, 0},
{ XK_space, Mod1Mask, "\033[32;3u", 0, 0},
{ XK_space, Mod1Mask|ControlMask, "\033[32;7u", 0, 0},
{ XK_space, Mod1Mask|ControlMask|ShiftMask, "\033[32;8u", 0, 0},
{ XK_space, Mod1Mask|ShiftMask, "\033[32;4u", 0, 0},
{ XK_space, ShiftMask, "\033[32;2u", 0, 0},
{ XK_0, ControlMask, "\033[48;5u", 0, 0},
{ XK_A, ControlMask|ShiftMask, "\033[65;6u", 0, 0},
{ XK_B, ControlMask|ShiftMask, "\033[66;6u", 0, 0},
{ XK_C, ControlMask|ShiftMask, "\033[67;6u", 0, 0},
{ XK_D, ControlMask|ShiftMask, "\033[68;6u", 0, 0},
{ XK_E, ControlMask|ShiftMask, "\033[69;6u", 0, 0},
{ XK_F, ControlMask|ShiftMask, "\033[70;6u", 0, 0},
{ XK_G, ControlMask|ShiftMask, "\033[71;6u", 0, 0},
{ XK_H, ControlMask|ShiftMask, "\033[72;6u", 0, 0},
{ XK_I, ControlMask|ShiftMask, "\033[73;6u", 0, 0},
{ XK_I, Mod1Mask|ControlMask|ShiftMask, "\033[73;8u", 0, 0},
{ XK_J, ControlMask|ShiftMask, "\033[75;6u", 0, 0},
{ XK_K, ControlMask|ShiftMask, "\033[74;6u", 0, 0},
{ XK_L, ControlMask|ShiftMask, "\033[76;6u", 0, 0},
{ XK_M, ControlMask|ShiftMask, "\033[77;6u", 0, 0},
{ XK_M, Mod1Mask|ControlMask|ShiftMask, "\033[77;8u", 0, 0},
{ XK_N, ControlMask|ShiftMask, "\033[78;6u", 0, 0},
{ XK_O, ControlMask|ShiftMask, "\033[79;6u", 0, 0},
{ XK_P, ControlMask|ShiftMask, "\033[80;6u", 0, 0},
{ XK_Q, ControlMask|ShiftMask, "\033[81;6u", 0, 0},
{ XK_R, ControlMask|ShiftMask, "\033[82;6u", 0, 0},
{ XK_S, ControlMask|ShiftMask, "\033[83;6u", 0, 0},
{ XK_T, ControlMask|ShiftMask, "\033[84;6u", 0, 0},
{ XK_U, ControlMask|ShiftMask, "\033[85;6u", 0, 0},
{ XK_V, ControlMask|ShiftMask, "\033[86;6u", 0, 0},
{ XK_W, ControlMask|ShiftMask, "\033[87;6u", 0, 0},
{ XK_X, ControlMask|ShiftMask, "\033[88;6u", 0, 0},
{ XK_Y, ControlMask|ShiftMask, "\033[89;6u", 0, 0},
{ XK_Z, ControlMask|ShiftMask, "\033[90;6u", 0, 0},
{ XK_0, Mod1Mask|ControlMask, "\033[48;7u", 0, 0},
{ XK_1, ControlMask, "\033[49;5u", 0, 0},
{ XK_1, Mod1Mask|ControlMask, "\033[49;7u", 0, 0},
{ XK_2, ControlMask, "\033[50;5u", 0, 0},
{ XK_2, Mod1Mask|ControlMask, "\033[50;7u", 0, 0},
{ XK_3, ControlMask, "\033[51;5u", 0, 0},
{ XK_3, Mod1Mask|ControlMask, "\033[51;7u", 0, 0},
{ XK_4, ControlMask, "\033[52;5u", 0, 0},
{ XK_4, Mod1Mask|ControlMask, "\033[52;7u", 0, 0},
{ XK_5, ControlMask, "\033[53;5u", 0, 0},
{ XK_5, Mod1Mask|ControlMask, "\033[53;7u", 0, 0},
{ XK_6, ControlMask, "\033[54;5u", 0, 0},
{ XK_6, Mod1Mask|ControlMask, "\033[54;7u", 0, 0},
{ XK_7, ControlMask, "\033[55;5u", 0, 0},
{ XK_7, Mod1Mask|ControlMask, "\033[55;7u", 0, 0},
{ XK_8, ControlMask, "\033[56;5u", 0, 0},
{ XK_8, Mod1Mask|ControlMask, "\033[56;7u", 0, 0},
{ XK_9, ControlMask, "\033[57;5u", 0, 0},
{ XK_9, Mod1Mask|ControlMask, "\033[57;7u", 0, 0},
{ XK_ampersand, ControlMask, "\033[38;5u", 0, 0},
{ XK_ampersand, ControlMask|ShiftMask, "\033[38;6u", 0, 0},
{ XK_ampersand, Mod1Mask, "\033[38;3u", 0, 0},
{ XK_ampersand, Mod1Mask|ControlMask, "\033[38;7u", 0, 0},
{ XK_ampersand, Mod1Mask|ControlMask|ShiftMask, "\033[38;8u", 0, 0},
{ XK_ampersand, Mod1Mask|ShiftMask, "\033[38;4u", 0, 0},
{ XK_apostrophe, ControlMask, "\033[39;5u", 0, 0},
{ XK_apostrophe, ControlMask|ShiftMask, "\033[39;6u", 0, 0},
{ XK_apostrophe, Mod1Mask, "\033[39;3u", 0, 0},
{ XK_apostrophe, Mod1Mask|ControlMask, "\033[39;7u", 0, 0},
{ XK_apostrophe, Mod1Mask|ControlMask|ShiftMask, "\033[39;8u", 0, 0},
{ XK_apostrophe, Mod1Mask|ShiftMask, "\033[39;4u", 0, 0},
{ XK_asciicircum, ControlMask, "\033[94;5u", 0, 0},
{ XK_asciicircum, ControlMask|ShiftMask, "\033[94;6u", 0, 0},
{ XK_asciicircum, Mod1Mask, "\033[94;3u", 0, 0},
{ XK_asciicircum, Mod1Mask|ControlMask, "\033[94;7u", 0, 0},
{ XK_asciicircum, Mod1Mask|ControlMask|ShiftMask, "\033[94;8u", 0, 0},
{ XK_asciicircum, Mod1Mask|ShiftMask, "\033[94;4u", 0, 0},
{ XK_asciitilde, ControlMask, "\033[126;5u", 0, 0},
{ XK_asciitilde, ControlMask|ShiftMask, "\033[126;6u", 0, 0},
{ XK_asciitilde, Mod1Mask, "\033[126;3u", 0, 0},
{ XK_asciitilde, Mod1Mask|ControlMask, "\033[126;7u", 0, 0},
{ XK_asciitilde, Mod1Mask|ControlMask|ShiftMask, "\033[126;8u", 0, 0},
{ XK_asciitilde, Mod1Mask|ShiftMask, "\033[126;4u", 0, 0},
{ XK_asterisk, ControlMask, "\033[42;5u", 0, 0},
{ XK_asterisk, ControlMask|ShiftMask, "\033[42;6u", 0, 0},
{ XK_asterisk, Mod1Mask, "\033[42;3u", 0, 0},
{ XK_asterisk, Mod1Mask|ControlMask, "\033[42;7u", 0, 0},
{ XK_asterisk, Mod1Mask|ControlMask|ShiftMask, "\033[42;8u", 0, 0},
{ XK_asterisk, Mod1Mask|ShiftMask, "\033[42;4u", 0, 0},
{ XK_at, ControlMask, "\033[64;5u", 0, 0},
{ XK_at, ControlMask|ShiftMask, "\033[64;6u", 0, 0},
{ XK_at, Mod1Mask, "\033[64;3u", 0, 0},
{ XK_at, Mod1Mask|ControlMask, "\033[64;7u", 0, 0},
{ XK_at, Mod1Mask|ControlMask|ShiftMask, "\033[64;8u", 0, 0},
{ XK_at, Mod1Mask|ShiftMask, "\033[64;4u", 0, 0},
{ XK_backslash, ControlMask, "\033[92;5u", 0, 0},
{ XK_backslash, ControlMask|ShiftMask, "\033[92;6u", 0, 0},
{ XK_backslash, Mod1Mask, "\033[92;3u", 0, 0},
{ XK_backslash, Mod1Mask|ControlMask, "\033[92;7u", 0, 0},
{ XK_backslash, Mod1Mask|ControlMask|ShiftMask, "\033[92;8u", 0, 0},
{ XK_backslash, Mod1Mask|ShiftMask, "\033[92;4u", 0, 0},
{ XK_bar, ControlMask, "\033[124;5u", 0, 0},
{ XK_bar, ControlMask|ShiftMask, "\033[124;6u", 0, 0},
{ XK_bar, Mod1Mask, "\033[124;3u", 0, 0},
{ XK_bar, Mod1Mask|ControlMask, "\033[124;7u", 0, 0},
{ XK_bar, Mod1Mask|ControlMask|ShiftMask, "\033[124;8u", 0, 0},
{ XK_bar, Mod1Mask|ShiftMask, "\033[124;4u", 0, 0},
{ XK_braceleft, ControlMask, "\033[123;5u", 0, 0},
{ XK_braceleft, ControlMask|ShiftMask, "\033[123;6u", 0, 0},
{ XK_braceleft, Mod1Mask, "\033[123;3u", 0, 0},
{ XK_braceleft, Mod1Mask|ControlMask, "\033[123;7u", 0, 0},
{ XK_braceleft, Mod1Mask|ControlMask|ShiftMask, "\033[123;8u", 0, 0},
{ XK_braceleft, Mod1Mask|ShiftMask, "\033[123;4u", 0, 0},
{ XK_braceright, ControlMask, "\033[125;5u", 0, 0},
{ XK_braceright, ControlMask|ShiftMask, "\033[125;6u", 0, 0},
{ XK_braceright, Mod1Mask, "\033[125;3u", 0, 0},
{ XK_braceright, Mod1Mask|ControlMask, "\033[125;7u", 0, 0},
{ XK_braceright, Mod1Mask|ControlMask|ShiftMask, "\033[125;8u", 0, 0},
{ XK_braceright, Mod1Mask|ShiftMask, "\033[125;4u", 0, 0},
{ XK_bracketleft, ControlMask, "\033[91;5u", 0, 0},
{ XK_bracketleft, ControlMask|ShiftMask, "\033[91;6u", 0, 0},
{ XK_bracketleft, Mod1Mask, "\033[91;3u", 0, 0},
{ XK_bracketleft, Mod1Mask|ControlMask, "\033[91;7u", 0, 0},
{ XK_bracketleft, Mod1Mask|ControlMask|ShiftMask, "\033[91;8u", 0, 0},
{ XK_bracketleft, Mod1Mask|ShiftMask, "\033[91;4u", 0, 0},
{ XK_bracketright, ControlMask, "\033[93;5u", 0, 0},
{ XK_bracketright, ControlMask|ShiftMask, "\033[93;6u", 0, 0},
{ XK_bracketright, Mod1Mask, "\033[93;3u", 0, 0},
{ XK_bracketright, Mod1Mask|ControlMask, "\033[93;7u", 0, 0},
{ XK_bracketright, Mod1Mask|ControlMask|ShiftMask, "\033[93;8u", 0, 0},
{ XK_bracketright, Mod1Mask|ShiftMask, "\033[93;4u", 0, 0},
{ XK_colon, ControlMask, "\033[58;5u", 0, 0},
{ XK_colon, ControlMask|ShiftMask, "\033[58;6u", 0, 0},
{ XK_colon, Mod1Mask, "\033[58;3u", 0, 0},
{ XK_colon, Mod1Mask|ControlMask, "\033[58;7u", 0, 0},
{ XK_colon, Mod1Mask|ControlMask|ShiftMask, "\033[58;8u", 0, 0},
{ XK_colon, Mod1Mask|ShiftMask, "\033[58;4u", 0, 0},
{ XK_comma, ControlMask, "\033[44;5u", 0, 0},
{ XK_comma, ControlMask|ShiftMask, "\033[44;6u", 0, 0},
{ XK_comma, Mod1Mask, "\033[44;3u", 0, 0},
{ XK_comma, Mod1Mask|ControlMask, "\033[44;7u", 0, 0},
{ XK_comma, Mod1Mask|ControlMask|ShiftMask, "\033[44;8u", 0, 0},
{ XK_comma, Mod1Mask|ShiftMask, "\033[44;4u", 0, 0},
{ XK_dollar, ControlMask, "\033[36;5u", 0, 0},
{ XK_dollar, ControlMask|ShiftMask, "\033[36;6u", 0, 0},
{ XK_dollar, Mod1Mask, "\033[36;3u", 0, 0},
{ XK_dollar, Mod1Mask|ControlMask, "\033[36;7u", 0, 0},
{ XK_dollar, Mod1Mask|ControlMask|ShiftMask, "\033[36;8u", 0, 0},
{ XK_dollar, Mod1Mask|ShiftMask, "\033[36;4u", 0, 0},
{ XK_equal, ControlMask, "\033[61;5u", 0, 0},
{ XK_equal, ControlMask|ShiftMask, "\033[61;6u", 0, 0},
{ XK_equal, Mod1Mask, "\033[61;3u", 0, 0},
{ XK_equal, Mod1Mask|ControlMask, "\033[61;7u", 0, 0},
{ XK_equal, Mod1Mask|ControlMask|ShiftMask, "\033[61;8u", 0, 0},
{ XK_equal, Mod1Mask|ShiftMask, "\033[61;4u", 0, 0},
{ XK_exclam, ControlMask, "\033[33;5u", 0, 0},
{ XK_exclam, ControlMask|ShiftMask, "\033[33;6u", 0, 0},
{ XK_exclam, Mod1Mask, "\033[33;3u", 0, 0},
{ XK_exclam, Mod1Mask|ControlMask, "\033[33;7u", 0, 0},
{ XK_exclam, Mod1Mask|ControlMask|ShiftMask, "\033[33;8u", 0, 0},
{ XK_exclam, Mod1Mask|ShiftMask, "\033[33;4u", 0, 0},
{ XK_grave, ControlMask, "\033[96;5u", 0, 0},
{ XK_grave, ControlMask|ShiftMask, "\033[96;6u", 0, 0},
{ XK_grave, Mod1Mask, "\033[96;3u", 0, 0},
{ XK_grave, Mod1Mask|ControlMask, "\033[96;7u", 0, 0},
{ XK_grave, Mod1Mask|ControlMask|ShiftMask, "\033[96;8u", 0, 0},
{ XK_grave, Mod1Mask|ShiftMask, "\033[96;4u", 0, 0},
{ XK_greater, ControlMask, "\033[62;5u", 0, 0},
{ XK_greater, ControlMask|ShiftMask, "\033[62;6u", 0, 0},
{ XK_greater, Mod1Mask, "\033[62;3u", 0, 0},
{ XK_greater, Mod1Mask|ControlMask, "\033[62;7u", 0, 0},
{ XK_greater, Mod1Mask|ControlMask|ShiftMask, "\033[62;8u", 0, 0},
{ XK_greater, Mod1Mask|ShiftMask, "\033[62;4u", 0, 0},
{ XK_less, ControlMask, "\033[60;5u", 0, 0},
{ XK_less, ControlMask|ShiftMask, "\033[60;6u", 0, 0},
{ XK_less, Mod1Mask, "\033[60;3u", 0, 0},
{ XK_less, Mod1Mask|ControlMask, "\033[60;7u", 0, 0},
{ XK_less, Mod1Mask|ControlMask|ShiftMask, "\033[60;8u", 0, 0},
{ XK_less, Mod1Mask|ShiftMask, "\033[60;4u", 0, 0},
{ XK_minus, ControlMask, "\033[45;5u", 0, 0},
{ XK_minus, ControlMask|ShiftMask, "\033[45;6u", 0, 0},
{ XK_minus, Mod1Mask, "\033[45;3u", 0, 0},
{ XK_minus, Mod1Mask|ControlMask, "\033[45;7u", 0, 0},
{ XK_minus, Mod1Mask|ControlMask|ShiftMask, "\033[45;8u", 0, 0},
{ XK_minus, Mod1Mask|ShiftMask, "\033[45;4u", 0, 0},
{ XK_numbersign, ControlMask, "\033[35;5u", 0, 0},
{ XK_numbersign, ControlMask|ShiftMask, "\033[35;6u", 0, 0},
{ XK_numbersign, Mod1Mask, "\033[35;3u", 0, 0},
{ XK_numbersign, Mod1Mask|ControlMask, "\033[35;7u", 0, 0},
{ XK_numbersign, Mod1Mask|ControlMask|ShiftMask, "\033[35;8u", 0, 0},
{ XK_numbersign, Mod1Mask|ShiftMask, "\033[35;4u", 0, 0},
{ XK_parenleft, ControlMask, "\033[40;5u", 0, 0},
{ XK_parenleft, ControlMask|ShiftMask, "\033[40;6u", 0, 0},
{ XK_parenleft, Mod1Mask, "\033[40;3u", 0, 0},
{ XK_parenleft, Mod1Mask|ControlMask, "\033[40;7u", 0, 0},
{ XK_parenleft, Mod1Mask|ControlMask|ShiftMask, "\033[40;8u", 0, 0},
{ XK_parenleft, Mod1Mask|ShiftMask, "\033[40;4u", 0, 0},
{ XK_parenright, ControlMask, "\033[41;5u", 0, 0},
{ XK_parenright, ControlMask|ShiftMask, "\033[41;6u", 0, 0},
{ XK_parenright, Mod1Mask, "\033[41;3u", 0, 0},
{ XK_parenright, Mod1Mask|ControlMask, "\033[41;7u", 0, 0},
{ XK_parenright, Mod1Mask|ControlMask|ShiftMask, "\033[41;8u", 0, 0},
{ XK_parenright, Mod1Mask|ShiftMask, "\033[41;4u", 0, 0},
{ XK_percent, ControlMask, "\033[37;5u", 0, 0},
{ XK_percent, ControlMask|ShiftMask, "\033[37;6u", 0, 0},
{ XK_percent, Mod1Mask, "\033[37;3u", 0, 0},
{ XK_percent, Mod1Mask|ControlMask, "\033[37;7u", 0, 0},
{ XK_percent, Mod1Mask|ControlMask|ShiftMask, "\033[37;8u", 0, 0},
{ XK_percent, Mod1Mask|ShiftMask, "\033[37;4u", 0, 0},
{ XK_period, ControlMask, "\033[46;5u", 0, 0},
{ XK_period, ControlMask|ShiftMask, "\033[46;6u", 0, 0},
{ XK_period, Mod1Mask|ControlMask, "\033[46;7u", 0, 0},
{ XK_period, Mod1Mask|ControlMask|ShiftMask, "\033[46;8u", 0, 0},
{ XK_period, Mod1Mask|ShiftMask, "\033[46;4u", 0, 0},
{ XK_plus, ControlMask, "\033[43;5u", 0, 0},
{ XK_plus, ControlMask|ShiftMask, "\033[43;6u", 0, 0},
{ XK_plus, Mod1Mask, "\033[43;3u", 0, 0},
{ XK_plus, Mod1Mask|ControlMask, "\033[43;7u", 0, 0},
{ XK_plus, Mod1Mask|ControlMask|ShiftMask, "\033[43;8u", 0, 0},
{ XK_plus, Mod1Mask|ShiftMask, "\033[43;4u", 0, 0},
{ XK_question, ControlMask, "\033[63;5u", 0, 0},
{ XK_question, ControlMask|ShiftMask, "\033[63;6u", 0, 0},
{ XK_question, Mod1Mask, "\033[63;3u", 0, 0},
{ XK_question, Mod1Mask|ControlMask, "\033[63;7u", 0, 0},
{ XK_question, Mod1Mask|ControlMask|ShiftMask, "\033[63;8u", 0, 0},
{ XK_question, Mod1Mask|ShiftMask, "\033[63;4u", 0, 0},
{ XK_quotedbl, ControlMask, "\033[34;5u", 0, 0},
{ XK_quotedbl, ControlMask|ShiftMask, "\033[34;6u", 0, 0},
{ XK_quotedbl, Mod1Mask, "\033[34;3u", 0, 0},
{ XK_quotedbl, Mod1Mask|ControlMask, "\033[34;7u", 0, 0},
{ XK_quotedbl, Mod1Mask|ControlMask|ShiftMask, "\033[34;8u", 0, 0},
{ XK_quotedbl, Mod1Mask|ShiftMask, "\033[34;4u", 0, 0},
{ XK_semicolon, ControlMask, "\033[59;5u", 0, 0},
{ XK_semicolon, ControlMask|ShiftMask, "\033[59;6u", 0, 0},
{ XK_semicolon, Mod1Mask, "\033[59;3u", 0, 0},
{ XK_semicolon, Mod1Mask|ControlMask, "\033[59;7u", 0, 0},
{ XK_semicolon, Mod1Mask|ControlMask|ShiftMask, "\033[59;8u", 0, 0},
{ XK_semicolon, Mod1Mask|ShiftMask, "\033[59;4u", 0, 0},
{ XK_slash, ControlMask|ShiftMask, "\033[47;6u", 0, 0},
{ XK_slash, Mod1Mask, "\033[47;3u", 0, 0},
{ XK_slash, Mod1Mask|ControlMask, "\033[47;7u", 0, 0},
{ XK_slash, Mod1Mask|ControlMask|ShiftMask, "\033[47;8u", 0, 0},
{ XK_slash, Mod1Mask|ShiftMask, "\033[47;4u", 0, 0},
{ XK_underscore, ControlMask, "\033[95;5u", 0, 0},
{ XK_underscore, ControlMask|ShiftMask, "\033[95;6u", 0, 0},
{ XK_underscore, Mod1Mask, "\033[95;3u", 0, 0},
{ XK_underscore, Mod1Mask|ControlMask, "\033[95;7u", 0, 0},
{ XK_underscore, Mod1Mask|ControlMask|ShiftMask, "\033[95;8u", 0, 0},
{ XK_underscore, Mod1Mask|ShiftMask, "\033[95;4u", 0, 0},
};

104
st-flexipatch/patch/font2.c Normal file
View File

@@ -0,0 +1,104 @@
int
xloadsparefont(FcPattern *pattern, int flags)
{
FcPattern *match;
FcResult result;
#if USE_XFTFONTMATCH_PATCH
match = XftFontMatch(xw.dpy, xw.scr, pattern, &result);
#else
match = FcFontMatch(NULL, pattern, &result);
#endif // USE_XFTFONTMATCH_PATCH
if (!match) {
return 1;
}
if (!(frc[frclen].font = XftFontOpenPattern(xw.dpy, match))) {
FcPatternDestroy(match);
return 1;
}
frc[frclen].flags = flags;
/* Believe U+0000 glyph will present in each default font */
frc[frclen].unicodep = 0;
frclen++;
return 0;
}
void
xloadsparefonts(void)
{
FcPattern *pattern;
double fontval;
int fc;
char **fp;
if (frclen != 0)
die("can't embed spare fonts. cache isn't empty");
/* Calculate count of spare fonts */
fc = sizeof(font2) / sizeof(*font2);
if (fc == 0)
return;
/* Allocate memory for cache entries. */
if (frccap < 4 * fc) {
frccap += 4 * fc - frccap;
frc = xrealloc(frc, frccap * sizeof(Fontcache));
}
for (fp = font2; fp - font2 < fc; ++fp) {
if (**fp == '-')
pattern = XftXlfdParse(*fp, False, False);
else
pattern = FcNameParse((FcChar8 *)*fp);
if (!pattern)
die("can't open spare font %s\n", *fp);
if (defaultfontsize > 0 && defaultfontsize != usedfontsize) {
if (FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &fontval) ==
FcResultMatch) {
fontval *= usedfontsize / defaultfontsize;
FcPatternDel(pattern, FC_PIXEL_SIZE);
FcPatternDel(pattern, FC_SIZE);
FcPatternAddDouble(pattern, FC_PIXEL_SIZE, fontval);
} else if (FcPatternGetDouble(pattern, FC_SIZE, 0, &fontval) ==
FcResultMatch) {
fontval *= usedfontsize / defaultfontsize;
FcPatternDel(pattern, FC_PIXEL_SIZE);
FcPatternDel(pattern, FC_SIZE);
FcPatternAddDouble(pattern, FC_SIZE, fontval);
}
}
FcPatternAddBool(pattern, FC_SCALABLE, 1);
#if !USE_XFTFONTMATCH_PATCH
FcConfigSubstitute(NULL, pattern, FcMatchPattern);
XftDefaultSubstitute(xw.dpy, xw.scr, pattern);
#endif // USE_XFTFONTMATCH_PATCH
if (xloadsparefont(pattern, FRC_NORMAL))
die("can't open spare font %s\n", *fp);
FcPatternDel(pattern, FC_SLANT);
FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC);
if (xloadsparefont(pattern, FRC_ITALIC))
die("can't open spare font %s\n", *fp);
FcPatternDel(pattern, FC_WEIGHT);
FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD);
if (xloadsparefont(pattern, FRC_ITALICBOLD))
die("can't open spare font %s\n", *fp);
FcPatternDel(pattern, FC_SLANT);
FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ROMAN);
if (xloadsparefont(pattern, FRC_BOLD))
die("can't open spare font %s\n", *fp);
FcPatternDestroy(pattern);
}
}

2
st-flexipatch/patch/font2.h Normal file
View File

@@ -0,0 +1,2 @@
static int xloadsparefont(FcPattern *, int);
static void xloadsparefonts(void);

17
st-flexipatch/patch/fullscreen_x.c Normal file
View File

@@ -0,0 +1,17 @@
void
fullscreen(const Arg *arg)
{
XEvent ev;
memset(&ev, 0, sizeof(ev));
ev.xclient.type = ClientMessage;
ev.xclient.message_type = xw.netwmstate;
ev.xclient.display = xw.dpy;
ev.xclient.window = xw.win;
ev.xclient.format = 32;
ev.xclient.data.l[0] = 2; /* _NET_WM_STATE_TOGGLE */
ev.xclient.data.l[1] = xw.netwmfullscreen;
XSendEvent(xw.dpy, DefaultRootWindow(xw.dpy), False, SubstructureNotifyMask|SubstructureRedirectMask, &ev);
}

1
st-flexipatch/patch/fullscreen_x.h Normal file
View File

@@ -0,0 +1 @@
static void fullscreen(const Arg *arg);

21
st-flexipatch/patch/invert.c Normal file
View File

@@ -0,0 +1,21 @@
static int invertcolors = 0;
void
invert(const Arg *dummy)
{
invertcolors = !invertcolors;
redraw();
}
Color
invertedcolor(Color *clr)
{
XRenderColor rc;
Color inverted;
rc.red = ~clr->color.red;
rc.green = ~clr->color.green;
rc.blue = ~clr->color.blue;
rc.alpha = clr->color.alpha;
XftColorAllocValue(xw.dpy, xw.vis, xw.cmap, &rc, &inverted);
return inverted;
}

1
st-flexipatch/patch/invert.h Normal file
View File

@@ -0,0 +1 @@
static void invert(const Arg *);

21
st-flexipatch/patch/iso14755.c Normal file
View File

@@ -0,0 +1,21 @@
void
iso14755(const Arg *arg)
{
FILE *p;
char *us, *e, codepoint[9], uc[UTF_SIZ];
unsigned long utf32;
if (!(p = popen(ISO14755CMD, "r")))
return;
us = fgets(codepoint, sizeof(codepoint), p);
pclose(p);
if (!us || *us == '\0' || *us == '-' || strlen(us) > 7)
return;
if ((utf32 = strtoul(us, &e, 16)) == ULONG_MAX ||
(*e != '\n' && *e != '\0'))
return;
ttywrite(uc, utf8encode(utf32, uc), 1);
}

6
st-flexipatch/patch/iso14755.h Normal file
View File

@@ -0,0 +1,6 @@
#define NUMMAXLEN(x) ((int)(sizeof(x) * 2.56 + 0.5) + 1)
/* constants */
#define ISO14755CMD "dmenu -w \"$WINDOWID\" -p codepoint: </dev/null"
void iso14755(const Arg *);

29
st-flexipatch/patch/keyboardselect_reflow.txt Normal file
View File

@@ -0,0 +1,29 @@
Shortcuts in keyboard selection mode:
h, j, k, l: move cursor left/down/up/right (also with arrow keys)
H, M, L: move cursor to the top/middle/bottom of the screen
Home, End: move cursor to the top/bottom of the screen
Backspace or 0, $ or A: move cursor to the beginning/end of the line
^ or I: move cursor to the beginning of the indented line
!: move cursor to the middle of the row
_: move cursor to the right edge of the screen
*: move cursor to the center of the screen
w, W jump forward to the start of a word
e, E jump forward to the end of a word
b, B jump backward to the start of a word
g, G: go to the first/last line
z: center the screen on the cursor
PgUp or K, PgDown or J: scroll the page up/down
/, ?: activate input mode and search up/down
n, N: repeat last search and search forward/backward
f, F: jump forward/backward to the given character
t, T: jump forward/backward to before the given character
; or r repeat previous f, t, F or T movement and move forward
, or R repeat previous f, t, F or T movement and move backward
v: toggle selection mode
V: toggle line selection mode
s: toggle regular/rectangular selection type
y: yank (copy) selected text
0 - 9: set the quantifier
Return: quit keyboard_select, yank and keep the highlight of the selection
Escape, q: quit keyboard_select/exit input mode/exit selection mode/reset quantifier

769
st-flexipatch/patch/keyboardselect_reflow_st.c Normal file
View File

@@ -0,0 +1,769 @@
#include <wctype.h>
enum keyboardselect_mode {
KBDS_MODE_MOVE = 0,
KBDS_MODE_SELECT = 1<<1,
KBDS_MODE_LSELECT = 1<<2,
KBDS_MODE_FIND = 1<<3,
KBDS_MODE_SEARCH = 1<<4,
};
enum cursor_wrap {
KBDS_WRAP_NONE = 0,
KBDS_WRAP_LINE = 1<<0,
KBDS_WRAP_EDGE = 1<<1,
};
typedef struct {
int x;
int y;
Line line;
int len;
} KCursor;
static int kbds_in_use, kbds_quant;
static int kbds_seltype = SEL_REGULAR;
static int kbds_mode, kbds_directsearch;
static int kbds_searchlen, kbds_searchdir, kbds_searchcase;
static int kbds_finddir, kbds_findtill;
static Glyph *kbds_searchstr;
static Rune kbds_findchar;
static KCursor kbds_c, kbds_oc;
void
kbds_drawstatusbar(int y)
{
static char *modes[] = { " MOVE ", "", " SELECT ", " RSELECT ", " LSELECT ",
" SEARCH FW ", " SEARCH BW ", " FIND FW ", " FIND BW " };
static char quant[20] = { ' ' };
static Glyph g;
int i, n, m;
int mlen, qlen;
if (!kbds_in_use)
return;
g.mode = ATTR_REVERSE;
g.fg = defaultfg;
g.bg = defaultbg;
if (y == 0) {
if (kbds_issearchmode())
m = 5 + (kbds_searchdir < 0 ? 1 : 0);
else if (kbds_mode & KBDS_MODE_FIND)
m = 7 + (kbds_finddir < 0 ? 1 : 0);
else if (kbds_mode & KBDS_MODE_SELECT)
m = 2 + (kbds_seltype == SEL_RECTANGULAR ? 1 : 0);
else
m = kbds_mode;
mlen = strlen(modes[m]);
qlen = kbds_quant ? snprintf(quant+1, sizeof quant-1, "%i", kbds_quant) + 1 : 0;
if (kbds_c.y != y || kbds_c.x < term.col - qlen - mlen) {
for (n = mlen, i = term.col-1; i >= 0 && n > 0; i--) {
g.u = modes[m][--n];
xdrawglyph(g, i, y);
}
for (n = qlen; i >= 0 && n > 0; i--) {
g.u = quant[--n];
xdrawglyph(g, i, y);
}
}
}
if (y == term.row-1 && kbds_issearchmode()) {
for (g.u = ' ', i = 0; i < term.col; i++)
xdrawglyph(g, i, y);
g.u = (kbds_searchdir > 0) ? '/' : '?';
xdrawglyph(g, 0, y);
for (i = 0; i < kbds_searchlen; i++) {
g.u = kbds_searchstr[i].u;
g.mode = kbds_searchstr[i].mode | ATTR_WIDE | ATTR_REVERSE;
if (g.u == ' ' || g.mode & ATTR_WDUMMY)
continue;
xdrawglyph(g, i + 1, y);
}
g.u = ' ';
g.mode = ATTR_NULL;
xdrawglyph(g, i + 1, y);
}
}
void
kbds_pasteintosearch(const char *data, int len, int append)
{
static char buf[BUFSIZ];
static int buflen;
Rune u;
int l, n, charsize;
if (!append)
buflen = 0;
for (; len > 0; len -= l, data += l) {
l = MIN(sizeof(buf) - buflen, len);
memmove(buf + buflen, data, l);
buflen += l;
for (n = 0; n < buflen; n += charsize) {
if (IS_SET(MODE_UTF8)) {
/* process a complete utf8 char */
charsize = utf8decode(buf + n, &u, buflen - n);
if (charsize == 0)
break;
} else {
u = buf[n] & 0xFF;
charsize = 1;
}
if (u > 0x1f && kbds_searchlen < term.col-2) {
kbds_searchstr[kbds_searchlen].u = u;
kbds_searchstr[kbds_searchlen++].mode = ATTR_NULL;
if (wcwidth(u) > 1) {
kbds_searchstr[kbds_searchlen-1].mode = ATTR_WIDE;
if (kbds_searchlen < term.col-2) {
kbds_searchstr[kbds_searchlen].u = 0;
kbds_searchstr[kbds_searchlen++].mode = ATTR_WDUMMY;
}
}
}
}
buflen -= n;
/* keep any incomplete UTF-8 byte sequence for the next call */
if (buflen > 0)
memmove(buf, buf + n, buflen);
}
term.dirty[term.row-1] = 1;
}
int
kbds_top(void)
{
return IS_SET(MODE_ALTSCREEN) ? 0 : -term.histf + term.scr;
}
int
kbds_bot(void)
{
return IS_SET(MODE_ALTSCREEN) ? term.row-1 : term.row-1 + term.scr;
}
int
kbds_iswrapped(KCursor *c)
{
return c->len > 0 && (c->line[c->len-1].mode & ATTR_WRAP);
}
int
kbds_isselectmode(void)
{
return kbds_in_use && (kbds_mode & (KBDS_MODE_SELECT | KBDS_MODE_LSELECT));
}
int
kbds_issearchmode(void)
{
return kbds_in_use && (kbds_mode & KBDS_MODE_SEARCH);
}
void
kbds_setmode(int mode)
{
kbds_mode = mode;
term.dirty[0] = 1;
}
void
kbds_selecttext(void)
{
if (kbds_isselectmode()) {
if (kbds_mode & KBDS_MODE_LSELECT)
selextend(term.col-1, kbds_c.y, SEL_RECTANGULAR, 0);
else
selextend(kbds_c.x, kbds_c.y, kbds_seltype, 0);
if (sel.mode == SEL_IDLE)
kbds_setmode(kbds_mode & ~(KBDS_MODE_SELECT | KBDS_MODE_LSELECT));
}
}
void
kbds_copytoclipboard(void)
{
if (kbds_mode & KBDS_MODE_LSELECT) {
selextend(term.col-1, kbds_c.y, SEL_RECTANGULAR, 1);
sel.type = SEL_REGULAR;
} else {
selextend(kbds_c.x, kbds_c.y, kbds_seltype, 1);
}
xsetsel(getsel());
#if !CLIPBOARD_PATCH
xclipcopy();
#endif // CLIPBOARD_PATCH
}
void
kbds_clearhighlights(void)
{
int x, y;
Line line;
for (y = (IS_SET(MODE_ALTSCREEN) ? 0 : -term.histf); y < term.row; y++) {
line = TLINEABS(y);
for (x = 0; x < term.col; x++)
line[x].mode &= ~ATTR_HIGHLIGHT;
}
tfulldirt();
}
int
kbds_moveto(int x, int y)
{
if (y < 0)
kscrollup(&((Arg){ .i = -y }));
else if (y >= term.row)
kscrolldown(&((Arg){ .i = y - term.row + 1 }));
kbds_c.x = (x < 0) ? 0 : (x > term.col-1) ? term.col-1 : x;
kbds_c.y = (y < 0) ? 0 : (y > term.row-1) ? term.row-1 : y;
kbds_c.line = TLINE(kbds_c.y);
kbds_c.len = tlinelen(kbds_c.line);
if (kbds_c.x > 0 && (kbds_c.line[kbds_c.x].mode & ATTR_WDUMMY))
kbds_c.x--;
}
int
kbds_moveforward(KCursor *c, int dx, int wrap)
{
KCursor n = *c;
n.x += dx;
if (n.x >= 0 && n.x < term.col && (n.line[n.x].mode & ATTR_WDUMMY))
n.x += dx;
if (n.x < 0) {
if (!wrap || --n.y < kbds_top())
return 0;
n.line = TLINE(n.y);
n.len = tlinelen(n.line);
if ((wrap & KBDS_WRAP_LINE) && kbds_iswrapped(&n))
n.x = n.len-1;
else if (wrap & KBDS_WRAP_EDGE)
n.x = term.col-1;
else
return 0;
n.x -= (n.x > 0 && (n.line[n.x].mode & ATTR_WDUMMY)) ? 1 : 0;
} else if (n.x >= term.col) {
if (((wrap & KBDS_WRAP_EDGE) ||
((wrap & KBDS_WRAP_LINE) && kbds_iswrapped(&n))) && ++n.y <= kbds_bot()) {
n.line = TLINE(n.y);
n.len = tlinelen(n.line);
n.x = 0;
} else {
return 0;
}
} else if (n.x >= n.len && dx > 0 && (wrap & KBDS_WRAP_LINE)) {
if (n.x == n.len && kbds_iswrapped(&n) && n.y < kbds_bot()) {
++n.y;
n.line = TLINE(n.y);
n.len = tlinelen(n.line);
n.x = 0;
} else if (!(wrap & KBDS_WRAP_EDGE)) {
return 0;
}
}
*c = n;
return 1;
}
int
kbds_ismatch(KCursor c)
{
KCursor m = c;
int i, next;
if (c.x + kbds_searchlen > c.len && (!kbds_iswrapped(&c) || c.y >= kbds_bot()))
return 0;
for (next = 0, i = 0; i < kbds_searchlen; i++) {
if (kbds_searchstr[i].mode & ATTR_WDUMMY)
continue;
if ((next++ && !kbds_moveforward(&c, 1, KBDS_WRAP_LINE)) ||
(kbds_searchcase && kbds_searchstr[i].u != c.line[c.x].u) ||
(!kbds_searchcase && kbds_searchstr[i].u != towlower(c.line[c.x].u)))
return 0;
}
for (i = 0; i < kbds_searchlen; i++) {
if (!(kbds_searchstr[i].mode & ATTR_WDUMMY)) {
m.line[m.x].mode |= ATTR_HIGHLIGHT;
kbds_moveforward(&m, 1, KBDS_WRAP_LINE);
}
}
return 1;
}
int
kbds_searchall(void)
{
KCursor c;
int count = 0;
if (!kbds_searchlen)
return 0;
for (c.y = kbds_top(); c.y <= kbds_bot(); c.y++) {
c.line = TLINE(c.y);
c.len = tlinelen(c.line);
for (c.x = 0; c.x < c.len; c.x++)
count += kbds_ismatch(c);
}
tfulldirt();
return count;
}
void
kbds_searchnext(int dir)
{
KCursor c = kbds_c, n = kbds_c;
int wrapped = 0;
if (!kbds_searchlen) {
kbds_quant = 0;
return;
}
if (dir < 0 && c.x > c.len)
c.x = c.len;
for (kbds_quant = MAX(kbds_quant, 1); kbds_quant > 0;) {
if (!kbds_moveforward(&c, dir, KBDS_WRAP_LINE)) {
c.y += dir;
if (c.y < kbds_top())
c.y = kbds_bot(), wrapped++;
else if (c.y > kbds_bot())
c.y = kbds_top(), wrapped++;
if (wrapped > 1)
break;;
c.line = TLINE(c.y);
c.len = tlinelen(c.line);
c.x = (dir < 0 && c.len > 0) ? c.len-1 : 0;
c.x -= (c.x > 0 && (c.line[c.x].mode & ATTR_WDUMMY)) ? 1 : 0;
}
if (kbds_ismatch(c)) {
n = c;
kbds_quant--;
}
}
kbds_moveto(n.x, n.y);
kbds_quant = 0;
}
void
kbds_findnext(int dir, int repeat)
{
KCursor prev, c = kbds_c, n = kbds_c;
int skipfirst, yoff = 0;
if (c.len <= 0 || kbds_findchar == 0) {
kbds_quant = 0;
return;
}
if (dir < 0 && c.x > c.len)
c.x = c.len;
kbds_quant = MAX(kbds_quant, 1);
skipfirst = (kbds_quant == 1 && repeat && kbds_findtill);
while (kbds_quant > 0) {
prev = c;
if (!kbds_moveforward(&c, dir, KBDS_WRAP_LINE))
break;
if (c.line[c.x].u == kbds_findchar) {
if (skipfirst && prev.x == kbds_c.x && prev.y == kbds_c.y) {
skipfirst = 0;
continue;
}
n.x = kbds_findtill ? prev.x : c.x;
n.y = c.y;
yoff = kbds_findtill ? prev.y - c.y : 0;
kbds_quant--;
}
}
kbds_moveto(n.x, n.y);
kbds_moveto(kbds_c.x, kbds_c.y + yoff);
kbds_quant = 0;
}
int
kbds_isdelim(KCursor c, int xoff, wchar_t *delims)
{
if (xoff && !kbds_moveforward(&c, xoff, KBDS_WRAP_LINE))
return 1;
return wcschr(delims, c.line[c.x].u) != NULL;
}
void
kbds_nextword(int start, int dir, wchar_t *delims)
{
KCursor c = kbds_c, n = kbds_c;
int xoff = start ? -1 : 1;
if (dir < 0 && c.x > c.len)
c.x = c.len;
else if (dir > 0 && c.x >= c.len && c.len > 0)
c.x = c.len-1;
for (kbds_quant = MAX(kbds_quant, 1); kbds_quant > 0;) {
if (!kbds_moveforward(&c, dir, KBDS_WRAP_LINE)) {
c.y += dir;
if (c.y < kbds_top() || c.y > kbds_bot())
break;
c.line = TLINE(c.y);
c.len = tlinelen(c.line);
c.x = (dir < 0 && c.len > 0) ? c.len-1 : 0;
c.x -= (c.x > 0 && (c.line[c.x].mode & ATTR_WDUMMY)) ? 1 : 0;
}
if (c.len > 0 &&
!kbds_isdelim(c, 0, delims) && kbds_isdelim(c, xoff, delims)) {
n = c;
kbds_quant--;
}
}
kbds_moveto(n.x, n.y);
kbds_quant = 0;
}
int
kbds_drawcursor(void)
{
if (kbds_in_use && (!kbds_issearchmode() || kbds_c.y != term.row-1)) {
#if LIGATURES_PATCH
xdrawcursor(kbds_c.x, kbds_c.y, TLINE(kbds_c.y)[kbds_c.x],
kbds_oc.x, kbds_oc.y, TLINE(kbds_oc.y)[kbds_oc.x],
TLINE(kbds_oc.y), term.col);
#else
xdrawcursor(kbds_c.x, kbds_c.y, TLINE(kbds_c.y)[kbds_c.x],
kbds_oc.x, kbds_oc.y, TLINE(kbds_oc.y)[kbds_oc.x]);
#endif // LIGATURES_PATCH
kbds_moveto(kbds_c.x, kbds_c.y);
kbds_oc = kbds_c;
}
return term.scr != 0 || kbds_in_use;
}
int
kbds_keyboardhandler(KeySym ksym, char *buf, int len, int forcequit)
{
int i, q, dy, eol, islast, prevscr, count, wrap;
int alt = IS_SET(MODE_ALTSCREEN);
Line line;
Rune u;
if (kbds_issearchmode() && !forcequit) {
switch (ksym) {
case XK_Escape:
kbds_searchlen = 0;
/* FALLTHROUGH */
case XK_Return:
for (kbds_searchcase = 0, i = 0; i < kbds_searchlen; i++) {
if (kbds_searchstr[i].u != towlower(kbds_searchstr[i].u)) {
kbds_searchcase = 1;
break;
}
}
count = kbds_searchall();
kbds_searchnext(kbds_searchdir);
kbds_selecttext();
kbds_setmode(kbds_mode & ~KBDS_MODE_SEARCH);
if (count == 0 && kbds_directsearch)
ksym = XK_Escape;
break;
case XK_BackSpace:
if (kbds_searchlen) {
kbds_searchlen--;
if (kbds_searchlen && (kbds_searchstr[kbds_searchlen].mode & ATTR_WDUMMY))
kbds_searchlen--;
}
break;
default:
if (len < 1 || kbds_searchlen >= term.col-2)
return 0;
utf8decode(buf, &u, len);
kbds_searchstr[kbds_searchlen].u = u;
kbds_searchstr[kbds_searchlen++].mode = ATTR_NULL;
if (wcwidth(u) > 1) {
kbds_searchstr[kbds_searchlen-1].mode = ATTR_WIDE;
if (kbds_searchlen < term.col-2) {
kbds_searchstr[kbds_searchlen].u = 0;
kbds_searchstr[kbds_searchlen++].mode = ATTR_WDUMMY;
}
}
break;
}
/* If the direct search is aborted, we just go to the next switch
* statement and exit the keyboard selection mode immediately */
if (!(ksym == XK_Escape && kbds_directsearch)) {
term.dirty[term.row-1] = 1;
return 0;
}
} else if ((kbds_mode & KBDS_MODE_FIND) && !forcequit) {
kbds_findchar = 0;
switch (ksym) {
case XK_Escape:
case XK_Return:
kbds_quant = 0;
break;
default:
if (len < 1)
return 0;
utf8decode(buf, &kbds_findchar, len);
kbds_findnext(kbds_finddir, 0);
kbds_selecttext();
break;
}
kbds_setmode(kbds_mode & ~KBDS_MODE_FIND);
return 0;
}
switch (ksym) {
case -1:
kbds_searchstr = xmalloc(term.col * sizeof(Glyph));
kbds_in_use = 1;
kbds_moveto(term.c.x, term.c.y);
kbds_oc = kbds_c;
kbds_setmode(KBDS_MODE_MOVE);
return MODE_KBDSELECT;
case XK_V:
if (kbds_mode & KBDS_MODE_LSELECT) {
selclear();
kbds_setmode(kbds_mode & ~(KBDS_MODE_SELECT | KBDS_MODE_LSELECT));
} else if (kbds_mode & KBDS_MODE_SELECT) {
selextend(term.col-1, kbds_c.y, SEL_RECTANGULAR, 0);
sel.ob.x = 0;
tfulldirt();
kbds_setmode((kbds_mode ^ KBDS_MODE_SELECT) | KBDS_MODE_LSELECT);
} else {
selstart(0, kbds_c.y, 0);
selextend(term.col-1, kbds_c.y, SEL_RECTANGULAR, 0);
kbds_setmode(kbds_mode | KBDS_MODE_LSELECT);
}
break;
case XK_v:
if (kbds_mode & KBDS_MODE_SELECT) {
selclear();
kbds_setmode(kbds_mode & ~(KBDS_MODE_SELECT | KBDS_MODE_LSELECT));
} else if (kbds_mode & KBDS_MODE_LSELECT) {
selextend(kbds_c.x, kbds_c.y, kbds_seltype, 0);
kbds_setmode((kbds_mode ^ KBDS_MODE_LSELECT) | KBDS_MODE_SELECT);
} else {
selstart(kbds_c.x, kbds_c.y, 0);
kbds_setmode(kbds_mode | KBDS_MODE_SELECT);
}
break;
case XK_s:
if (!(kbds_mode & KBDS_MODE_LSELECT)) {
kbds_seltype ^= (SEL_REGULAR | SEL_RECTANGULAR);
selextend(kbds_c.x, kbds_c.y, kbds_seltype, 0);
}
break;
case XK_y:
case XK_Y:
if (kbds_isselectmode()) {
kbds_copytoclipboard();
selclear();
kbds_setmode(kbds_mode & ~(KBDS_MODE_SELECT | KBDS_MODE_LSELECT));
}
break;
case -2:
case -3:
case XK_slash:
case XK_KP_Divide:
case XK_question:
kbds_directsearch = (ksym == -2 || ksym == -3);
kbds_searchdir = (ksym == XK_question || ksym == -3) ? -1 : 1;
kbds_searchlen = 0;
kbds_setmode(kbds_mode | KBDS_MODE_SEARCH);
kbds_clearhighlights();
return 0;
case XK_q:
case XK_Escape:
if (!kbds_in_use)
return 0;
if (kbds_quant && !forcequit) {
kbds_quant = 0;
break;
}
selclear();
if (kbds_isselectmode() && !forcequit) {
kbds_setmode(KBDS_MODE_MOVE);
break;
}
kbds_setmode(KBDS_MODE_MOVE);
/* FALLTHROUGH */
case XK_Return:
if (kbds_isselectmode())
kbds_copytoclipboard();
kbds_in_use = kbds_quant = 0;
free(kbds_searchstr);
kscrolldown(&((Arg){ .i = term.histf }));
kbds_clearhighlights();
return MODE_KBDSELECT;
case XK_n:
case XK_N:
kbds_searchnext(ksym == XK_n ? kbds_searchdir : -kbds_searchdir);
break;
case XK_BackSpace:
kbds_moveto(0, kbds_c.y);
break;
case XK_exclam:
kbds_moveto(term.col/2, kbds_c.y);
break;
case XK_underscore:
kbds_moveto(term.col-1, kbds_c.y);
break;
case XK_dollar:
case XK_A:
eol = kbds_c.len-1;
line = kbds_c.line;
islast = (kbds_c.x == eol || (kbds_c.x == eol-1 && (line[eol-1].mode & ATTR_WIDE)));
if (islast && kbds_iswrapped(&kbds_c) && kbds_c.y < kbds_bot())
kbds_moveto(tlinelen(TLINE(kbds_c.y+1))-1, kbds_c.y+1);
else
kbds_moveto(islast ? term.col-1 : eol, kbds_c.y);
break;
case XK_asciicircum:
case XK_I:
for (i = 0; i < kbds_c.len && kbds_c.line[i].u == ' '; i++)
;
kbds_moveto((i < kbds_c.len) ? i : 0, kbds_c.y);
break;
case XK_End:
case XK_KP_End:
kbds_moveto(kbds_c.x, term.row-1);
break;
case XK_Home:
case XK_KP_Home:
case XK_H:
kbds_moveto(kbds_c.x, 0);
break;
case XK_M:
kbds_moveto(kbds_c.x, alt ? (term.row-1) / 2
: MIN(term.c.y + term.scr, term.row-1) / 2);
break;
case XK_L:
kbds_moveto(kbds_c.x, alt ? term.row-1
: MIN(term.c.y + term.scr, term.row-1));
break;
case XK_Page_Up:
case XK_KP_Page_Up:
case XK_K:
prevscr = term.scr;
kscrollup(&((Arg){ .i = term.row }));
kbds_moveto(kbds_c.x, alt ? 0
: MAX(0, kbds_c.y - term.row + term.scr - prevscr));
break;
case XK_Page_Down:
case XK_KP_Page_Down:
case XK_J:
prevscr = term.scr;
kscrolldown(&((Arg){ .i = term.row }));
kbds_moveto(kbds_c.x, alt ? term.row-1
: MIN(MIN(term.c.y + term.scr, term.row-1),
kbds_c.y + term.row + term.scr - prevscr));
break;
case XK_asterisk:
case XK_KP_Multiply:
kbds_moveto(term.col/2, (term.row-1) / 2);
break;
case XK_g:
kscrollup(&((Arg){ .i = term.histf }));
kbds_moveto(kbds_c.x, 0);
break;
case XK_G:
kscrolldown(&((Arg){ .i = term.histf }));
kbds_moveto(kbds_c.x, alt ? term.row-1 : term.c.y);
break;
case XK_b:
case XK_B:
kbds_nextword(1, -1, (ksym == XK_b) ? kbds_sdelim : kbds_ldelim);
break;
case XK_w:
case XK_W:
kbds_nextword(1, +1, (ksym == XK_w) ? kbds_sdelim : kbds_ldelim);
break;
case XK_e:
case XK_E:
kbds_nextword(0, +1, (ksym == XK_e) ? kbds_sdelim : kbds_ldelim);
break;
case XK_z:
prevscr = term.scr;
dy = kbds_c.y - (term.row-1) / 2;
if (dy <= 0)
kscrollup(&((Arg){ .i = -dy }));
else
kscrolldown(&((Arg){ .i = dy }));
kbds_moveto(kbds_c.x, kbds_c.y + term.scr - prevscr);
break;
case XK_f:
case XK_F:
case XK_t:
case XK_T:
kbds_finddir = (ksym == XK_f || ksym == XK_t) ? 1 : -1;
kbds_findtill = (ksym == XK_t || ksym == XK_T) ? 1 : 0;
kbds_setmode(kbds_mode | KBDS_MODE_FIND);
return 0;
case XK_semicolon:
case XK_r:
kbds_findnext(kbds_finddir, 1);
break;
case XK_comma:
case XK_R:
kbds_findnext(-kbds_finddir, 1);
break;
case XK_0:
case XK_KP_0:
if (!kbds_quant) {
kbds_moveto(0, kbds_c.y);
break;
}
/* FALLTHROUGH */
default:
if (ksym >= XK_0 && ksym <= XK_9) { /* 0-9 keyboard */
q = (kbds_quant * 10) + (ksym ^ XK_0);
kbds_quant = q <= 99999999 ? q : kbds_quant;
term.dirty[0] = 1;
return 0;
} else if (ksym >= XK_KP_0 && ksym <= XK_KP_9) { /* 0-9 numpad */
q = (kbds_quant * 10) + (ksym ^ XK_KP_0);
kbds_quant = q <= 99999999 ? q : kbds_quant;
term.dirty[0] = 1;
return 0;
} else if (ksym == XK_k || ksym == XK_h)
i = ksym & 1;
else if (ksym == XK_l || ksym == XK_j)
i = ((ksym & 6) | 4) >> 1;
else if (ksym >= XK_KP_Left && ksym <= XK_KP_Down)
i = ksym - XK_KP_Left;
else if ((XK_Home & ksym) != XK_Home || (i = (ksym ^ XK_Home) - 1) > 3)
return 0;
kbds_quant = (kbds_quant ? kbds_quant : 1);
if (i & 1) {
kbds_c.y += kbds_quant * (i & 2 ? 1 : -1);
} else {
for (;kbds_quant > 0; kbds_quant--) {
if (!kbds_moveforward(&kbds_c, (i & 2) ? 1 : -1,
KBDS_WRAP_LINE | KBDS_WRAP_EDGE))
break;
}
}
kbds_moveto(kbds_c.x, kbds_c.y);
}
kbds_selecttext();
kbds_quant = 0;
term.dirty[0] = 1;
return 0;
}

6
st-flexipatch/patch/keyboardselect_reflow_st.h Normal file
View File

@@ -0,0 +1,6 @@
void kbds_drawstatusbar(int y);
void kbds_pasteintosearch(const char *, int, int);
int kbds_isselectmode(void);
int kbds_issearchmode(void);
int kbds_drawcursor(void);
int kbds_keyboardhandler(KeySym, char *, int, int);

16
st-flexipatch/patch/keyboardselect_reflow_x.c Normal file
View File

@@ -0,0 +1,16 @@
void keyboard_select(const Arg *dummy)
{
win.mode ^= kbds_keyboardhandler(-1, NULL, 0, 0);
}
void searchforward(const Arg *)
{
win.mode ^= kbds_keyboardhandler(-1, NULL, 0, 0);
kbds_keyboardhandler(-2, NULL, 0, 0);
}
void searchbackward(const Arg *)
{
win.mode ^= kbds_keyboardhandler(-1, NULL, 0, 0);
kbds_keyboardhandler(-3, NULL, 0, 0);
}

3
st-flexipatch/patch/keyboardselect_reflow_x.h Normal file
View File

@@ -0,0 +1,3 @@
void keyboard_select(const Arg *);
void searchforward(const Arg *);
void searchbackward(const Arg *);

240
st-flexipatch/patch/keyboardselect_st.c Normal file
View File

@@ -0,0 +1,240 @@
void set_notifmode(int type, KeySym ksym)
{
static char *lib[] = { " MOVE ", " SEL "};
static Glyph *g, *deb, *fin;
static int col, bot;
if (ksym == -1) {
free(g);
col = term.col, bot = term.bot;
g = xmalloc(col * sizeof(Glyph));
memcpy(g, term.line[bot], col * sizeof(Glyph));
} else if (ksym == -2)
memcpy(term.line[bot], g, col * sizeof(Glyph));
if ( type < 2 ) {
char *z = lib[type];
for (deb = &term.line[bot][col - 6], fin = &term.line[bot][col]; deb < fin; z++, deb++)
deb->mode = ATTR_REVERSE,
deb->u = *z,
deb->fg = defaultfg, deb->bg = defaultbg;
} else if (type < 5)
memcpy(term.line[bot], g, col * sizeof(Glyph));
else {
for (deb = &term.line[bot][0], fin = &term.line[bot][col]; deb < fin; deb++)
deb->mode = ATTR_REVERSE,
deb->u = ' ',
deb->fg = defaultfg, deb->bg = defaultbg;
term.line[bot][0].u = ksym;
}
term.dirty[bot] = 1;
drawregion(0, bot, col, bot + 1);
}
#if SCROLLBACK_PATCH && KEYBOARDSELECT_PATCH
Glyph getglyph(Term term, int y, int x)
{
Glyph g;
int realy = y - term.scr;
if(realy >= 0) {
g = term.line[realy][x];
} else {
realy = term.histi - term.scr + y + 1;
g = term.hist[realy][x];
}
return g;
}
#endif
void select_or_drawcursor(int selectsearch_mode, int type)
{
int done = 0;
if (selectsearch_mode & 1) {
selextend(term.c.x, term.c.y, type, done);
xsetsel(getsel());
} else {
#if LIGATURES_PATCH
xdrawcursor(term.c.x, term.c.y, term.line[term.c.y][term.c.x],
term.ocx, term.ocy, term.line[term.ocy][term.ocx],
term.line[term.ocy], term.col);
#elif SCROLLBACK_PATCH && KEYBOARDSELECT_PATCH
xdrawcursor(term.c.x, term.c.y, getglyph(term, term.c.y, term.c.x),
term.ocx, term.ocy, getglyph(term, term.ocy, term.ocx));
#else
xdrawcursor(term.c.x, term.c.y, term.line[term.c.y][term.c.x],
term.ocx, term.ocy, term.line[term.ocy][term.ocx]);
#endif // LIGATURES_PATCH
}
}
void search(int selectsearch_mode, Rune *target, int ptarget, int incr, int type, TCursor *cu)
{
Rune *r;
int i, bound = (term.col * cu->y + cu->x) * (incr > 0) + incr;
for (i = term.col * term.c.y + term.c.x + incr; i != bound; i += incr) {
for (r = target; r - target < ptarget; r++) {
if (*r == term.line[(i + r - target) / term.col][(i + r - target) % term.col].u) {
if (r - target == ptarget - 1)
break;
} else {
r = NULL;
break;
}
}
if (r != NULL)
break;
}
if (i != bound) {
term.c.y = i / term.col, term.c.x = i % term.col;
select_or_drawcursor(selectsearch_mode, type);
}
}
int trt_kbdselect(KeySym ksym, char *buf, int len)
{
static TCursor cu;
static Rune target[64];
static int type = 1, ptarget, in_use;
static int sens, quant;
static char selectsearch_mode;
int i, bound, *xy;
if (selectsearch_mode & 2) {
if (ksym == XK_Return) {
selectsearch_mode ^= 2;
set_notifmode(selectsearch_mode, -2);
if (ksym == XK_Escape)
ptarget = 0;
return 0;
} else if (ksym == XK_BackSpace) {
if (!ptarget)
return 0;
term.line[term.bot][ptarget--].u = ' ';
} else if (len < 1) {
return 0;
} else if (ptarget == term.col || ksym == XK_Escape) {
return 0;
} else {
utf8decode(buf, &target[ptarget++], len);
term.line[term.bot][ptarget].u = target[ptarget - 1];
}
if (ksym != XK_BackSpace)
search(selectsearch_mode, &target[0], ptarget, sens, type, &cu);
term.dirty[term.bot] = 1;
drawregion(0, term.bot, term.col, term.bot + 1);
return 0;
}
switch (ksym) {
case -1:
in_use = 1;
cu.x = term.c.x, cu.y = term.c.y;
set_notifmode(0, ksym);
return MODE_KBDSELECT;
case XK_s:
if (selectsearch_mode & 1)
selclear();
else
selstart(term.c.x, term.c.y, 0);
set_notifmode(selectsearch_mode ^= 1, ksym);
break;
case XK_t:
selextend(term.c.x, term.c.y, type ^= 3, i = 0); /* 2 fois */
selextend(term.c.x, term.c.y, type, i = 0);
break;
case XK_slash:
case XK_KP_Divide:
case XK_question:
ksym &= XK_question; /* Divide to slash */
sens = (ksym == XK_slash) ? -1 : 1;
ptarget = 0;
set_notifmode(15, ksym);
selectsearch_mode ^= 2;
break;
case XK_Escape:
if (!in_use)
break;
selclear();
case XK_Return:
set_notifmode(4, ksym);
term.c.x = cu.x, term.c.y = cu.y;
select_or_drawcursor(selectsearch_mode = 0, type);
in_use = quant = 0;
return MODE_KBDSELECT;
case XK_n:
case XK_N:
if (ptarget)
search(selectsearch_mode, &target[0], ptarget, (ksym == XK_n) ? -1 : 1, type, &cu);
break;
case XK_BackSpace:
term.c.x = 0;
select_or_drawcursor(selectsearch_mode, type);
break;
case XK_dollar:
term.c.x = term.col - 1;
select_or_drawcursor(selectsearch_mode, type);
break;
case XK_Home:
term.c.x = 0, term.c.y = 0;
select_or_drawcursor(selectsearch_mode, type);
break;
case XK_End:
term.c.x = cu.x, term.c.y = cu.y;
select_or_drawcursor(selectsearch_mode, type);
break;
case XK_Page_Up:
case XK_Page_Down:
term.c.y = (ksym == XK_Prior ) ? 0 : cu.y;
select_or_drawcursor(selectsearch_mode, type);
break;
case XK_exclam:
term.c.x = term.col >> 1;
select_or_drawcursor(selectsearch_mode, type);
break;
case XK_asterisk:
case XK_KP_Multiply:
term.c.x = term.col >> 1;
case XK_underscore:
term.c.y = cu.y >> 1;
select_or_drawcursor(selectsearch_mode, type);
break;
default:
if (ksym >= XK_0 && ksym <= XK_9) { /* 0-9 keyboard */
quant = (quant * 10) + (ksym ^ XK_0);
return 0;
} else if (ksym >= XK_KP_0 && ksym <= XK_KP_9) { /* 0-9 numpad */
quant = (quant * 10) + (ksym ^ XK_KP_0);
return 0;
} else if (ksym == XK_k || ksym == XK_h)
i = ksym & 1;
else if (ksym == XK_l || ksym == XK_j)
i = ((ksym & 6) | 4) >> 1;
else if ((XK_Home & ksym) != XK_Home || (i = (ksym ^ XK_Home) - 1) > 3)
break;
xy = (i & 1) ? &term.c.y : &term.c.x;
sens = (i & 2) ? 1 : -1;
bound = (i >> 1 ^ 1) ? 0 : (i ^ 3) ? term.col - 1 : term.bot;
if (quant == 0)
quant++;
if (*xy == bound && ((sens < 0 && bound == 0) || (sens > 0 && bound > 0)))
break;
*xy += quant * sens;
if (*xy < 0 || ( bound > 0 && *xy > bound))
*xy = bound;
select_or_drawcursor(selectsearch_mode, type);
}
quant = 0;
return 0;
}

2
st-flexipatch/patch/keyboardselect_st.h Normal file
View File

@@ -0,0 +1,2 @@
void toggle_winmode(int);
int trt_kbdselect(KeySym, char *, int);

7
st-flexipatch/patch/keyboardselect_x.c Normal file
View File

@@ -0,0 +1,7 @@
void toggle_winmode(int flag) {
win.mode ^= flag;
}
void keyboard_select(const Arg *dummy) {
win.mode ^= trt_kbdselect(-1, NULL, 0);
}

2
st-flexipatch/patch/keyboardselect_x.h Normal file
View File

@@ -0,0 +1,2 @@
void toggle_winmode(int);
void keyboard_select(const Arg *);

40
st-flexipatch/patch/netwmicon.c Normal file
View File

@@ -0,0 +1,40 @@
#include <gd.h>
void
setnetwmicon(void)
{
/* use a png-image to set _NET_WM_ICON */
FILE* file = fopen(ICON, "r");
if (file) {
/* load image in rgba-format */
const gdImagePtr icon_rgba = gdImageCreateFromPng(file);
fclose(file);
/* declare icon-variable which will store the image in bgra-format */
const int width = gdImageSX(icon_rgba);
const int height = gdImageSY(icon_rgba);
const int icon_n = width * height + 2;
long icon_bgra[icon_n];
/* set width and height of the icon */
int i = 0;
icon_bgra[i++] = width;
icon_bgra[i++] = height;
/* rgba -> bgra */
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
const int pixel_rgba = gdImageGetPixel(icon_rgba, x, y);
unsigned char *pixel_bgra = (unsigned char *) &icon_bgra[i++];
pixel_bgra[0] = gdImageBlue(icon_rgba, pixel_rgba);
pixel_bgra[1] = gdImageGreen(icon_rgba, pixel_rgba);
pixel_bgra[2] = gdImageRed(icon_rgba, pixel_rgba);
/* scale alpha from 0-127 to 0-255 */
const unsigned char alpha = 127 - gdImageAlpha(icon_rgba, pixel_rgba);
pixel_bgra[3] = alpha == 127 ? 255 : alpha * 2;
}
}
gdImageDestroy(icon_rgba);
/* set _NET_WM_ICON */
xw.netwmicon = XInternAtom(xw.dpy, "_NET_WM_ICON", False);
XChangeProperty(xw.dpy, xw.win, xw.netwmicon, XA_CARDINAL, 32,
PropModeReplace, (uchar *) icon_bgra, icon_n);
}
}

1
st-flexipatch/patch/netwmicon.h Normal file
View File

@@ -0,0 +1 @@
static void setnetwmicon(void);

46
st-flexipatch/patch/netwmicon_ff.c Normal file
View File

@@ -0,0 +1,46 @@
void
setnetwmicon(void)
{
/* use a farbfeld image to set _NET_WM_ICON */
FILE* file = fopen(ICON, "r");
if (file) {
unsigned char buf[16] = {0};
int hasdata = fread(buf,1,16,file);
if (memcmp(buf,"farbfeld",8)) {
fprintf(stderr,"netwmicon: file %s is not a farbfeld image\n", ICON);
fclose(file);
return;
}
/* declare icon-variable which will store the image in bgra-format */
const int width=(buf[8]<<24)|(buf[9]<<16)|(buf[10]<<8)|buf[11];
const int height=(buf[12]<<24)|(buf[13]<<16)|(buf[14]<<8)|buf[15];
const int icon_n = width * height + 2;
long icon_bgra[icon_n];
/* set width and height of the icon */
int i = 0;
icon_bgra[i++] = width;
icon_bgra[i++] = height;
/* rgba -> bgra */
for (int y = 0; y < height && hasdata; y++) {
for (int x = 0; x < width && hasdata; x++) {
unsigned char *pixel_bgra = (unsigned char *) &icon_bgra[i++];
hasdata = fread(buf,1,8,file);
pixel_bgra[0] = buf[4];
pixel_bgra[1] = buf[2];
pixel_bgra[2] = buf[0];
pixel_bgra[3] = buf[6];
}
}
/* set _NET_WM_ICON */
xw.netwmicon = XInternAtom(xw.dpy, "_NET_WM_ICON", False);
XChangeProperty(xw.dpy, xw.win, xw.netwmicon, XA_CARDINAL, 32,
PropModeReplace, (uchar *) icon_bgra, icon_n);
fclose(file);
}
}

686
st-flexipatch/patch/netwmicon_icon.h Normal file
View File

@@ -0,0 +1,686 @@
unsigned long icon[] = {
64, 64,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x02000000, 0x03000000,
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000,
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000,
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000,
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000,
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000,
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000,
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000,
0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000, 0x03000000,
0x03000000, 0x02000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x03000000,
0x20181818, 0x4e868686, 0x74b2b2b2, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6,
0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6,
0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6,
0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6,
0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6,
0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6,
0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6,
0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6,
0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x77b6b6b6, 0x74b2b2b2,
0x4e868686, 0x20181818, 0x03000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x03000000, 0x46717171, 0xcef3f3f3, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xcdf3f3f3,
0x456f6f6f, 0x03000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x211f1f1f, 0xd1f4f4f4, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xd0f3f3f3, 0x20181818,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x59959595, 0xffffffff,
0xffffffff, 0xff8b8b8b, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff8c8c8c, 0xffffffff, 0xffffffff, 0x58919191, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x83b3b3b3, 0xffffffff, 0xffffffff, 0xff262626,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff262626, 0xffffffff,
0xffffffff, 0x83b3b3b3, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8eacacac, 0xffffffff,
0xffffffff, 0xff222222, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff222222, 0xffffffff,
0xffffffff, 0x8eacacac, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8eacacac, 0xffffffff,
0xffffffff, 0xff222222, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff2c2c2c, 0xffe0e0e0, 0xff1c1c1c, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff202020,
0xff6c6c6c, 0xffffffff, 0xff6d6d6d, 0xff3c3c3c, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff222222, 0xffffffff,
0xffffffff, 0x8eacacac, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff2d2d2d, 0xffe1e1e1, 0xffc3c3c3, 0xffffffff,
0xffa1a1a1, 0xffdddddd, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8eacacac, 0xffffffff,
0xffffffff, 0xff222222, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff7f7f7f, 0xffbfbfbf, 0xff303030, 0xffffffff, 0xff1c1c1c, 0xff181818,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff717171, 0xffe1e1e1,
0xff545454, 0xffffffff, 0xff1c1c1c, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff222222, 0xffffffff,
0xffffffff, 0x8eacacac, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff1c1c1c, 0xffa1a1a1, 0xfff6f6f6, 0xffffffff,
0xffaeaeae, 0xff515151, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8eacacac, 0xffffffff,
0xffffffff, 0xff222222, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff343434, 0xffffffff, 0xff979797, 0xfff9f9f9,
0xff515151, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff303030, 0xffffffff, 0xff1c1c1c, 0xffb3b3b3, 0xff8d8d8d, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff222222, 0xffffffff,
0xffffffff, 0x8eacacac, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff686868, 0xff616161, 0xff3c3c3c, 0xffffffff,
0xff545454, 0xffe8e8e8, 0xff5b5b5b, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8eacacac, 0xffffffff,
0xffffffff, 0xff222222, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff4b4b4b, 0xffb3b3b3, 0xffe1e1e1, 0xffffffff, 0xffcccccc, 0xff717171,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff303030, 0xffffffff, 0xff1c1c1c, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff222222, 0xffffffff,
0xffffffff, 0x8eacacac, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff2b2b2b, 0xffd1d1d1,
0xff1c1c1c, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8eacacac, 0xffffffff,
0xffffffff, 0xff222222, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff7f7f7f, 0xffe9e9e9, 0xffe9e9e9, 0xffe9e9e9, 0xffe9e9e9,
0xffe9e9e9, 0xffe9e9e9, 0xff444444, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff222222, 0xffffffff,
0xffffffff, 0x8eacacac, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8eacacac, 0xffffffff,
0xffffffff, 0xff222222, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff222222, 0xffffffff,
0xffffffff, 0x8eacacac, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8eacacac, 0xffffffff,
0xffffffff, 0xff222222, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff222222, 0xffffffff,
0xffffffff, 0x8eacacac, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8eacacac, 0xffffffff,
0xffffffff, 0xff222222, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff222222, 0xffffffff,
0xffffffff, 0x8eacacac, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8eacacac, 0xffffffff,
0xffffffff, 0xff222222, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff222222, 0xffffffff,
0xffffffff, 0x8eacacac, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8eacacac, 0xffffffff,
0xffffffff, 0xff222222, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff222222, 0xffffffff,
0xffffffff, 0x8eacacac, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8eacacac, 0xffffffff,
0xffffffff, 0xff222222, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff222222, 0xffffffff,
0xffffffff, 0x8eacacac, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x8eacacac, 0xffffffff, 0xffffffff, 0xff222222, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8eacacac, 0xffffffff,
0xffffffff, 0xff222222, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff222222, 0xffffffff, 0xffffffff, 0x8eacacac, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x8aacacac, 0xffffffff, 0xffffffff, 0xff262626,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff171717,
0xff171717, 0xff171717, 0xff171717, 0xff171717, 0xff262626, 0xffffffff,
0xffffffff, 0x8aacacac, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x62858585, 0xffffffff, 0xffffffff, 0xff8c8c8c, 0xff373737, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636, 0xff363636,
0xff363636, 0xff373737, 0xff8d8d8d, 0xffffffff, 0xffffffff, 0x62828282,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x21171717, 0xdee2e2e2,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xdee1e1e1, 0x1f101010, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x03000000, 0x5f4e4e4e, 0xdbe1e1e1, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xdae1e1e1,
0x5f4b4b4b, 0x03000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x12000000, 0x48040404, 0x6d595959, 0x8d929292, 0x90979797,
0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797,
0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797,
0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797,
0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797,
0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797,
0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797,
0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797,
0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797, 0x90979797,
0x90979797, 0x8d929292, 0x6d595959, 0x48040404, 0x12000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x06000000, 0x22000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000,
0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000,
0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000,
0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000,
0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000,
0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000,
0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000,
0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000,
0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000, 0x29000000,
0x22000000, 0x06000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
};

7
st-flexipatch/patch/netwmicon_legacy.c Normal file
View File

@@ -0,0 +1,7 @@
void
setnetwmicon(void)
{
xw.netwmicon = XInternAtom(xw.dpy, "_NET_WM_ICON", False);
XChangeProperty(xw.dpy, xw.win, xw.netwmicon, XA_CARDINAL, 32,
PropModeReplace, (uchar *)&icon, LEN(icon));
}

44
st-flexipatch/patch/newterm.c Normal file
View File

@@ -0,0 +1,44 @@
extern char* argv0;
static char*
getcwd_by_pid(pid_t pid) {
static char cwd[32];
snprintf(cwd, sizeof cwd, "/proc/%d/cwd", pid);
return cwd;
}
void
newterm(const Arg* a)
{
switch (fork()) {
case -1:
die("fork failed: %s\n", strerror(errno));
break;
case 0:
switch (fork()) {
case -1:
die("fork failed: %s\n", strerror(errno));
break;
case 0:
#if OSC7_PATCH
if (term.cwd) {
if (chdir(term.cwd) == 0) {
/* We need to put the working directory also in PWD, so that
* the shell starts in the right directory if `cwd` is a
* symlink. */
setenv("PWD", term.cwd, 1);
}
} else {
chdir(getcwd_by_pid(pid));
}
#else
chdir(getcwd_by_pid(pid));
#endif // OSC7_PATCH
execl("/proc/self/exe", argv0, NULL);
exit(1);
default:
exit(0);
}
}
}

1
st-flexipatch/patch/newterm.h Normal file
View File

@@ -0,0 +1 @@
void newterm(const Arg *);

19
st-flexipatch/patch/opencopied.c Normal file
View File

@@ -0,0 +1,19 @@
void
opencopied(const Arg *arg)
{
int res;
size_t const max_cmd = 2048;
char * const clip = xsel.clipboard;
if (!clip) {
fprintf(stderr, "Warning: nothing copied to clipboard\n");
return;
}
/* account for space/quote (3) and \0 (1) and & (1) */
/* e.g.: xdg-open "https://st.suckless.org"& */
size_t const cmd_size = max_cmd + strlen(clip) + 5;
char cmd[cmd_size];
snprintf(cmd, cmd_size, "%s \"%s\"&", (char *)arg->v, clip);
res = system(cmd);
}

1
st-flexipatch/patch/opencopied.h Normal file
View File

@@ -0,0 +1 @@
void opencopied(const Arg *);

13
st-flexipatch/patch/openselectedtext.c Normal file
View File

@@ -0,0 +1,13 @@
void
selopen(const Arg *dummy)
{
pid_t chpid;
if ((chpid = fork()) == 0) {
if (fork() == 0)
execlp("xdg-open", "xdg-open", getsel(), NULL);
exit(1);
}
if (chpid > 0)
waitpid(chpid, NULL, 0);
}

3
st-flexipatch/patch/openselectedtext.h Normal file
View File

@@ -0,0 +1,3 @@
#include <sys/wait.h>
static void selopen(const Arg *);

230
st-flexipatch/patch/openurlonclick.c Normal file
View File

@@ -0,0 +1,230 @@
#if !REFLOW_PATCH
#if SCROLLBACK_PATCH
#define TLINEURL(y) TLINE(y)
#else
#define TLINEURL(y) term.line[y]
#endif // SCROLLBACK_PATCH
#endif // REFLOW_PATCH
int url_x1, url_y1, url_x2, url_y2 = -1;
int url_draw, url_click, url_maxcol;
static int
isvalidurlchar(Rune u)
{
/* () and [] can appear in urls, but excluding them here will reduce false
* positives when figuring out where a given url ends. See copyurl patch.
*/
static char urlchars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789-._~:/?#@!$&'*+,;=%";
return u < 128 && strchr(urlchars, (int)u) != NULL;
}
/* find the end of the wrapped line */
#if REFLOW_PATCH
static int
findeowl(Line line)
{
int i = term.col - 1;
do {
if (line[i].mode & ATTR_WRAP)
return i;
} while (!(line[i].mode & ATTR_SET) && --i >= 0);
return -1;
}
#else
static int
findeowl(int row)
{
#if COLUMNS_PATCH
int col = term.maxcol - 1;
#else
int col = term.col - 1;
#endif // COLUMNS_PATCH
do {
if (TLINEURL(row)[col].mode & ATTR_WRAP)
return col;
} while (TLINEURL(row)[col].u == ' ' && --col >= 0);
return -1;
}
#endif // REFLOW_PATCH
void
clearurl(void)
{
while (url_y1 <= url_y2 && url_y1 < term.row)
term.dirty[url_y1++] = 1;
url_y2 = -1;
}
#if REFLOW_PATCH
char *
detecturl(int col, int row, int draw)
{
static char url[2048];
Line line;
int x1, y1, x2, y2;
int i = sizeof(url)/2+1, j = sizeof(url)/2;
int row_start = row, col_start = col;
int minrow = tisaltscr() ? 0 : term.scr - term.histf;
int maxrow = tisaltscr() ? term.row - 1 : term.scr + term.row - 1;
/* clear previously underlined url */
if (draw)
clearurl();
url_maxcol = 0;
line = TLINE(row);
if (!isvalidurlchar(line[col].u))
return NULL;
/* find the first character of url */
do {
x1 = col_start, y1 = row_start;
url_maxcol = MAX(url_maxcol, x1);
url[--i] = line[col_start].u;
if (--col_start < 0) {
if (--row_start < minrow || (col_start = findeowl(TLINE(row_start))) < 0)
break;
line = TLINE(row_start);
}
} while (isvalidurlchar(line[col_start].u) && i > 0);
/* early detection */
if (url[i] != 'h')
return NULL;
/* find the last character of url */
line = TLINE(row);
do {
x2 = col, y2 = row;
url_maxcol = MAX(url_maxcol, x2);
url[j++] = line[col].u;
if (line[col++].mode & ATTR_WRAP) {
if (++row > maxrow)
break;
col = 0;
line = TLINE(row);
}
} while (col < term.col && isvalidurlchar(line[col].u) && j < sizeof(url)-1);
url[j] = 0;
if (strncmp("https://", &url[i], 8) && strncmp("http://", &url[i], 7))
return NULL;
/* Ignore some trailing characters to improve detection. */
/* Alacritty and many other terminals also ignore these. */
if (strchr(",.;:?!", (int)(url[j-1])) != NULL) {
x2 = MAX(x2-1, 0);
url[j-1] = 0;
}
/* underline url (see xdrawglyphfontspecs() in x.c) */
if (draw) {
url_x1 = (y1 >= 0) ? x1 : 0;
url_x2 = (y2 < term.row) ? x2 : url_maxcol;
url_y1 = MAX(y1, 0);
url_y2 = MIN(y2, term.row-1);
url_draw = 1;
for (y1 = url_y1; y1 <= url_y2; y1++)
term.dirty[y1] = 1;
}
return &url[i];
}
#else
char *
detecturl(int col, int row, int draw)
{
static char url[2048];
int x1, y1, x2, y2, wrapped;
int row_start = row;
int col_start = col;
int i = sizeof(url)/2+1, j = sizeof(url)/2;
#if SCROLLBACK_PATCH
int minrow = term.scr - term.histn, maxrow = term.scr + term.row - 1;
/* Fixme: MODE_ALTSCREEN is not defined here, I had to use the magic number 1<<2 */
if ((term.mode & (1 << 2)) != 0)
minrow = 0, maxrow = term.row - 1;
#else
int minrow = 0, maxrow = term.row - 1;
#endif // SCROLLBACK_PATCH
url_maxcol = 0;
/* clear previously underlined url */
if (draw)
clearurl();
if (!isvalidurlchar(TLINEURL(row)[col].u))
return NULL;
/* find the first character of url */
do {
x1 = col_start, y1 = row_start;
url_maxcol = MAX(url_maxcol, x1);
url[--i] = TLINEURL(row_start)[col_start].u;
if (--col_start < 0) {
if (--row_start < minrow || (col_start = findeowl(row_start)) < 0)
break;
}
} while (i > 0 && isvalidurlchar(TLINEURL(row_start)[col_start].u));
/* early detection */
if (url[i] != 'h')
return NULL;
/* find the last character of url */
do {
x2 = col, y2 = row;
url_maxcol = MAX(url_maxcol, x2);
url[j++] = TLINEURL(row)[col].u;
wrapped = TLINEURL(row)[col].mode & ATTR_WRAP;
#if COLUMNS_PATCH
if (++col >= term.maxcol || wrapped) {
#else
if (++col >= term.col || wrapped) {
#endif // COLUMNS_PATCH
col = 0;
if (++row > maxrow || !wrapped)
break;
}
} while (j < sizeof(url)-1 && isvalidurlchar(TLINEURL(row)[col].u));
url[j] = 0;
if (strncmp("https://", &url[i], 8) && strncmp("http://", &url[i], 7))
return NULL;
/* underline url (see xdrawglyphfontspecs() in x.c) */
if (draw) {
url_x1 = (y1 >= 0) ? x1 : 0;
url_x2 = (y2 < term.row) ? x2 : url_maxcol;
url_y1 = MAX(y1, 0);
url_y2 = MIN(y2, term.row-1);
url_draw = 1;
for (y1 = url_y1; y1 <= url_y2; y1++)
term.dirty[y1] = 1;
}
return &url[i];
}
#endif // REFLOW_PATCH
void
openUrlOnClick(int col, int row, char* url_opener)
{
char *url = detecturl(col, row, 1);
if (url) {
extern char **environ;
pid_t junk;
char *argv[] = { url_opener, url, NULL };
posix_spawnp(&junk, argv[0], NULL, NULL, argv, environ);
}
}

8
st-flexipatch/patch/openurlonclick.h Normal file
View File

@@ -0,0 +1,8 @@
#include <spawn.h>
static inline void restoremousecursor(void) {
if (!(win.mode & MODE_MOUSE) && xw.pointerisvisible)
XDefineCursor(xw.dpy, xw.win, xw.vpointer);
}
static void clearurl(void);
static void openUrlOnClick(int col, int row, char* url_opener);

29
st-flexipatch/patch/osc133.c Normal file
View File

@@ -0,0 +1,29 @@
void
scrolltoprompt(const Arg *arg)
{
int x, y;
#if REFLOW_PATCH
int top = term.scr - term.histf;
#else
int top = term.scr - term.histn;
#endif // REFLOW_PATCH
int bot = term.scr + term.row-1;
int dy = arg->i;
Line line;
if (!dy || tisaltscr())
return;
for (y = dy; y >= top && y <= bot; y += dy) {
for (line = TLINE(y), x = 0; x < term.col; x++) {
if (line[x].mode & ATTR_FTCS_PROMPT)
goto scroll;
}
}
scroll:
if (dy < 0)
kscrollup(&((Arg){ .i = -y }));
else
kscrolldown(&((Arg){ .i = y }));
}

1
st-flexipatch/patch/osc133.h Normal file
View File

@@ -0,0 +1 @@
static void scrolltoprompt(const Arg *);

74
st-flexipatch/patch/osc7.c Normal file
View File

@@ -0,0 +1,74 @@
static int
hex2int(char c)
{
if (c >= '0' && c <= '9')
return c - '0';
else if (c >= 'a' && c <= 'f')
return c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
return c - 'A' + 10;
else
return -1;
}
int
osc7parsecwd(const char *uri)
{
const char *auth, *host, *hostend;
char *path, decoded[PATH_MAX], thishost[_POSIX_HOST_NAME_MAX];
size_t i, decodedlen, hostlen, urilen;
int h1, h2;
if (!term.cwd) {
term.cwd = xmalloc(sizeof(decoded));
term.cwd[0] = '\0';
}
/* reset cwd if uri is empty */
if ((urilen = strlen(uri)) == 0) {
term.cwd[0] = '\0';
return 1;
}
/* decode uri */
for (decodedlen = 0, i = 0; i < urilen; i++) {
if (uri[i] == '%' && i <= urilen-3 &&
(h1 = hex2int(uri[i+1])) >= 0 && (h2 = hex2int(uri[i+2])) >= 0) {
decoded[decodedlen++] = (h1 << 4) | h2;
i += 2;
} else {
decoded[decodedlen++] = uri[i];
}
if (decodedlen == sizeof(decoded)) {
fprintf(stderr, "erresc (OSC 7): uri is too long\n");
return 0;
}
}
decoded[decodedlen] = '\0';
/* check scheme */
if (decodedlen < 5 || strncmp("file:", decoded, 5) != 0) {
fprintf(stderr, "erresc (OSC 7): scheme is not supported: '%s'\n", uri);
return 0;
}
/* find start of authority */
if (decodedlen < 7 || decoded[5] != '/' || decoded[6] != '/') {
fprintf(stderr, "erresc (OSC 7): invalid uri: '%s'\n", uri);
return 0;
}
auth = decoded + 7;
/* find start of path and reset cwd if path is missing */
if ((path = strchr(auth, '/')) == NULL) {
term.cwd[0] = '\0';
return 1;
}
/* ignore path if host is not localhost */
host = ((host = memchr(auth, '@', path - auth)) != NULL) ? host+1 : auth;
hostend = ((hostend = memchr(host, ':', path - host)) != NULL) ? hostend : path;
hostlen = hostend - host;
if (gethostname(thishost, sizeof(thishost)) < 0)
thishost[0] = '\0';
if (hostlen > 0 &&
!(hostlen == 9 && strncmp("localhost", host, hostlen) == 0) &&
!(hostlen == strlen(thishost) && strncmp(host, thishost, hostlen) == 0)) {
return 0;
}
memcpy(term.cwd, path, decodedlen - (path - decoded) + 1);
return 1;
}

1
st-flexipatch/patch/osc7.h Normal file
View File

@@ -0,0 +1 @@
static int osc7parsecwd(const char *);

923
st-flexipatch/patch/reflow.c Normal file
View File

@@ -0,0 +1,923 @@
void
tloaddefscreen(int clear, int loadcursor)
{
int col, row, alt = IS_SET(MODE_ALTSCREEN);
if (alt) {
if (clear) {
tclearregion(0, 0, term.col-1, term.row-1, 1);
#if SIXEL_PATCH
tdeleteimages();
#endif // SIXEL_PATCH
}
col = term.col, row = term.row;
tswapscreen();
}
if (loadcursor)
tcursor(CURSOR_LOAD);
if (alt)
tresizedef(col, row);
}
void
tloadaltscreen(int clear, int savecursor)
{
int col, row, def = !IS_SET(MODE_ALTSCREEN);
if (savecursor)
tcursor(CURSOR_SAVE);
if (def) {
col = term.col, row = term.row;
kscrolldown(&((Arg){ .i = term.scr }));
tswapscreen();
tresizealt(col, row);
}
if (clear) {
tclearregion(0, 0, term.col-1, term.row-1, 1);
#if SIXEL_PATCH
tdeleteimages();
#endif // SIXEL_PATCH
}
}
void
selmove(int n)
{
sel.ob.y += n, sel.nb.y += n;
sel.oe.y += n, sel.ne.y += n;
}
void
tclearglyph(Glyph *gp, int usecurattr)
{
if (usecurattr) {
gp->fg = term.c.attr.fg;
gp->bg = term.c.attr.bg;
} else {
gp->fg = defaultfg;
gp->bg = defaultbg;
}
gp->mode = ATTR_NULL;
gp->u = ' ';
}
#if SIXEL_PATCH
void
treflow_moveimages(int oldy, int newy)
{
ImageList *im;
for (im = term.images; im; im = im->next) {
if (im->y == oldy)
im->reflow_y = newy;
}
}
#endif // SIXEL_PATCH
void
treflow(int col, int row)
{
int i, j;
int oce, nce, bot, scr;
int ox = 0, oy = -term.histf, nx = 0, ny = -1, len;
int cy = -1; /* proxy for new y coordinate of cursor */
int buflen, nlines;
Line *buf, bufline, line;
#if SIXEL_PATCH
ImageList *im, *next;
for (im = term.images; im; im = im->next)
im->reflow_y = INT_MIN; /* unset reflow_y */
#endif // SIXEL_PATCH
/* y coordinate of cursor line end */
for (oce = term.c.y; oce < term.row - 1 &&
tiswrapped(term.line[oce]); oce++);
nlines = HISTSIZE + row;
buf = xmalloc(nlines * sizeof(Line));
do {
if (!nx && ++ny < nlines)
buf[ny] = xmalloc(col * sizeof(Glyph));
if (!ox) {
line = TLINEABS(oy);
len = tlinelen(line);
}
if (oy == term.c.y) {
if (!ox)
len = MAX(len, term.c.x + 1);
/* update cursor */
if (cy < 0 && term.c.x - ox < col - nx) {
term.c.x = nx + term.c.x - ox, cy = ny;
UPDATEWRAPNEXT(0, col);
}
}
/* get reflowed lines in buf */
bufline = buf[ny % nlines];
if (col - nx > len - ox) {
memcpy(&bufline[nx], &line[ox], (len-ox) * sizeof(Glyph));
nx += len - ox;
if (len == 0 || !(line[len - 1].mode & ATTR_WRAP)) {
for (j = nx; j < col; j++)
tclearglyph(&bufline[j], 0);
#if SIXEL_PATCH
treflow_moveimages(oy+term.scr, ny);
#endif // SIXEL_PATCH
nx = 0;
} else if (nx > 0) {
bufline[nx - 1].mode &= ~ATTR_WRAP;
}
ox = 0, oy++;
} else if (col - nx == len - ox) {
memcpy(&bufline[nx], &line[ox], (col-nx) * sizeof(Glyph));
#if SIXEL_PATCH
treflow_moveimages(oy+term.scr, ny);
#endif // SIXEL_PATCH
ox = 0, oy++, nx = 0;
} else/* if (col - nx < len - ox) */ {
memcpy(&bufline[nx], &line[ox], (col-nx) * sizeof(Glyph));
if (bufline[col - 1].mode & ATTR_WIDE) {
bufline[col - 2].mode |= ATTR_WRAP;
tclearglyph(&bufline[col - 1], 0);
ox--;
} else {
bufline[col - 1].mode |= ATTR_WRAP;
}
#if SIXEL_PATCH
treflow_moveimages(oy+term.scr, ny);
#endif // SIXEL_PATCH
ox += col - nx;
nx = 0;
}
} while (oy <= oce);
if (nx)
for (j = nx; j < col; j++)
tclearglyph(&bufline[j], 0);
/* free extra lines */
for (i = row; i < term.row; i++)
free(term.line[i]);
/* resize to new height */
term.line = xrealloc(term.line, row * sizeof(Line));
buflen = MIN(ny + 1, nlines);
bot = MIN(ny, row - 1);
scr = MAX(row - term.row, 0);
/* update y coordinate of cursor line end */
nce = MIN(oce + scr, bot);
/* update cursor y coordinate */
term.c.y = nce - (ny - cy);
if (term.c.y < 0) {
j = nce, nce = MIN(nce + -term.c.y, bot);
term.c.y += nce - j;
while (term.c.y < 0) {
free(buf[ny-- % nlines]);
buflen--;
term.c.y++;
}
}
/* allocate new rows */
for (i = row - 1; i > nce; i--) {
if (i >= term.row)
term.line[i] = xmalloc(col * sizeof(Glyph));
else
term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph));
for (j = 0; j < col; j++)
tclearglyph(&term.line[i][j], 0);
}
/* fill visible area */
for (/*i = nce */; i >= term.row; i--, ny--, buflen--)
term.line[i] = buf[ny % nlines];
for (/*i = term.row - 1 */; i >= 0; i--, ny--, buflen--) {
free(term.line[i]);
term.line[i] = buf[ny % nlines];
}
/* fill lines in history buffer and update term.histf */
for (/*i = -1 */; buflen > 0 && i >= -HISTSIZE; i--, ny--, buflen--) {
j = (term.histi + i + 1 + HISTSIZE) % HISTSIZE;
free(term.hist[j]);
term.hist[j] = buf[ny % nlines];
}
term.histf = -i - 1;
term.scr = MIN(term.scr, term.histf);
/* resize rest of the history lines */
for (/*i = -term.histf - 1 */; i >= -HISTSIZE; i--) {
j = (term.histi + i + 1 + HISTSIZE) % HISTSIZE;
term.hist[j] = xrealloc(term.hist[j], col * sizeof(Glyph));
}
#if SIXEL_PATCH
/* move images to the final position */
for (im = term.images; im; im = next) {
next = im->next;
if (im->reflow_y == INT_MIN) {
delete_image(im);
} else {
im->y = im->reflow_y - term.histf + term.scr - (ny + 1);
if (im->y - term.scr < -HISTSIZE || im->y - term.scr >= row)
delete_image(im);
}
}
/* expand images into new text cells */
for (im = term.images; im; im = im->next) {
j = MIN(im->x + im->cols, col);
line = TLINE(im->y);
for (i = im->x; i < j; i++) {
if (!(line[i].mode & ATTR_SET))
line[i].mode |= ATTR_SIXEL;
}
}
#endif // SIXEL_PATCH
for (; buflen > 0; ny--, buflen--)
free(buf[ny % nlines]);
free(buf);
}
void
rscrolldown(int n)
{
int i;
Line temp;
/* can never be true as of now
if (IS_SET(MODE_ALTSCREEN))
return; */
if ((n = MIN(n, term.histf)) <= 0)
return;
for (i = term.c.y + n; i >= n; i--) {
temp = term.line[i];
term.line[i] = term.line[i-n];
term.line[i-n] = temp;
}
for (/*i = n - 1 */; i >= 0; i--) {
temp = term.line[i];
term.line[i] = term.hist[term.histi];
term.hist[term.histi] = temp;
term.histi = (term.histi - 1 + HISTSIZE) % HISTSIZE;
}
term.c.y += n;
term.histf -= n;
if ((i = term.scr - n) >= 0) {
term.scr = i;
} else {
#if SIXEL_PATCH
scroll_images(n - term.scr);
#endif // SIXEL_PATCH
term.scr = 0;
if (sel.ob.x != -1 && !sel.alt)
selmove(-i);
}
}
void
tresizedef(int col, int row)
{
int i, j;
/* return if dimensions haven't changed */
if (term.col == col && term.row == row) {
tfulldirt();
return;
}
if (col != term.col) {
if (!sel.alt)
selremove();
treflow(col, row);
} else {
/* slide screen up if otherwise cursor would get out of the screen */
if (term.c.y >= row) {
tscrollup(0, term.row - 1, term.c.y - row + 1, SCROLL_RESIZE);
term.c.y = row - 1;
}
for (i = row; i < term.row; i++)
free(term.line[i]);
/* resize to new height */
term.line = xrealloc(term.line, row * sizeof(Line));
/* allocate any new rows */
for (i = term.row; i < row; i++) {
term.line[i] = xmalloc(col * sizeof(Glyph));
for (j = 0; j < col; j++)
tclearglyph(&term.line[i][j], 0);
}
/* scroll down as much as height has increased */
rscrolldown(row - term.row);
}
/* update terminal size */
term.col = col, term.row = row;
/* reset scrolling region */
term.top = 0, term.bot = row - 1;
/* dirty all lines */
tfulldirt();
}
void
tresizealt(int col, int row)
{
int i, j;
#if SIXEL_PATCH
ImageList *im, *next;
#endif // SIXEL_PATCH
/* return if dimensions haven't changed */
if (term.col == col && term.row == row) {
tfulldirt();
return;
}
if (sel.alt)
selremove();
/* slide screen up if otherwise cursor would get out of the screen */
for (i = 0; i <= term.c.y - row; i++)
free(term.line[i]);
if (i > 0) {
/* ensure that both src and dst are not NULL */
memmove(term.line, term.line + i, row * sizeof(Line));
#if SIXEL_PATCH
scroll_images(-i);
#endif // SIXEL_PATCH
term.c.y = row - 1;
}
for (i += row; i < term.row; i++)
free(term.line[i]);
/* resize to new height */
term.line = xrealloc(term.line, row * sizeof(Line));
/* resize to new width */
for (i = 0; i < MIN(row, term.row); i++) {
term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph));
for (j = term.col; j < col; j++)
tclearglyph(&term.line[i][j], 0);
}
/* allocate any new rows */
for (/*i = MIN(row, term.row) */; i < row; i++) {
term.line[i] = xmalloc(col * sizeof(Glyph));
for (j = 0; j < col; j++)
tclearglyph(&term.line[i][j], 0);
}
/* update cursor */
if (term.c.x >= col) {
term.c.state &= ~CURSOR_WRAPNEXT;
term.c.x = col - 1;
} else {
UPDATEWRAPNEXT(1, col);
}
/* update terminal size */
term.col = col, term.row = row;
/* reset scrolling region */
term.top = 0, term.bot = row - 1;
#if SIXEL_PATCH
/* delete or clip images if they are not inside the screen */
for (im = term.images; im; im = next) {
next = im->next;
if (im->x >= term.col || im->y >= term.row || im->y < 0) {
delete_image(im);
} else {
if ((im->cols = MIN(im->x + im->cols, term.col) - im->x) <= 0)
delete_image(im);
}
}
#endif // SIXEL_PATCH
/* dirty all lines */
tfulldirt();
}
void
kscrolldown(const Arg* a)
{
int n = a->i;
if (!term.scr || IS_SET(MODE_ALTSCREEN))
return;
if (n < 0)
n = MAX(term.row / -n, 1);
if (n <= term.scr) {
term.scr -= n;
} else {
n = term.scr;
term.scr = 0;
}
if (sel.ob.x != -1 && !sel.alt)
selmove(-n); /* negate change in term.scr */
tfulldirt();
#if SIXEL_PATCH
scroll_images(-1*n);
#endif // SIXEL_PATCH
#if OPENURLONCLICK_PATCH
if (n > 0)
restoremousecursor();
#endif // OPENURLONCLICK_PATCH
}
void
kscrollup(const Arg* a)
{
int n = a->i;
if (!term.histf || IS_SET(MODE_ALTSCREEN))
return;
if (n < 0)
n = MAX(term.row / -n, 1);
if (term.scr + n <= term.histf) {
term.scr += n;
} else {
n = term.histf - term.scr;
term.scr = term.histf;
}
if (sel.ob.x != -1 && !sel.alt)
selmove(n); /* negate change in term.scr */
tfulldirt();
#if SIXEL_PATCH
scroll_images(n);
#endif // SIXEL_PATCH
#if OPENURLONCLICK_PATCH
if (n > 0)
restoremousecursor();
#endif // OPENURLONCLICK_PATCH
}
void
tscrollup(int top, int bot, int n, int mode)
{
#if OPENURLONCLICK_PATCH
restoremousecursor();
#endif //OPENURLONCLICK_PATCH
int i, j, s;
Line temp;
int alt = IS_SET(MODE_ALTSCREEN);
int savehist = !alt && top == 0 && mode != SCROLL_NOSAVEHIST;
int scr = alt ? 0 : term.scr;
#if SIXEL_PATCH
int itop = top + scr, ibot = bot + scr;
ImageList *im, *next;
#endif // SIXEL_PATCH
if (n <= 0)
return;
n = MIN(n, bot-top+1);
if (savehist) {
for (i = 0; i < n; i++) {
term.histi = (term.histi + 1) % HISTSIZE;
temp = term.hist[term.histi];
for (j = 0; j < term.col; j++)
tclearglyph(&temp[j], 1);
term.hist[term.histi] = term.line[i];
term.line[i] = temp;
}
term.histf = MIN(term.histf + n, HISTSIZE);
s = n;
if (term.scr) {
j = term.scr;
term.scr = MIN(j + n, HISTSIZE);
s = j + n - term.scr;
}
if (mode != SCROLL_RESIZE)
tfulldirt();
} else {
tclearregion(0, top, term.col-1, top+n-1, 1);
tsetdirt(top + scr, bot + scr);
}
for (i = top; i <= bot-n; i++) {
temp = term.line[i];
term.line[i] = term.line[i+n];
term.line[i+n] = temp;
}
#if SIXEL_PATCH
if (alt || !savehist) {
/* move images, if they are inside the scrolling region */
for (im = term.images; im; im = next) {
next = im->next;
if (im->y >= itop && im->y <= ibot) {
im->y -= n;
if (im->y < itop)
delete_image(im);
}
}
} else {
/* move images, if they are inside the scrolling region or scrollback */
for (im = term.images; im; im = next) {
next = im->next;
im->y -= scr;
if (im->y < 0) {
im->y -= n;
} else if (im->y >= top && im->y <= bot) {
im->y -= n;
if (im->y < top)
im->y -= top; // move to scrollback
}
if (im->y < -HISTSIZE)
delete_image(im);
else
im->y += term.scr;
}
}
#endif // SIXEL_PATCH
if (sel.ob.x != -1 && sel.alt == alt) {
if (!savehist) {
selscroll(top, bot, -n);
} else if (s > 0) {
selmove(-s);
if (-term.scr + sel.nb.y < -term.histf)
selremove();
}
}
}
void
tscrolldown(int top, int n)
{
#if OPENURLONCLICK_PATCH
restoremousecursor();
#endif //OPENURLONCLICK_PATCH
int i, bot = term.bot;
int scr = IS_SET(MODE_ALTSCREEN) ? 0 : term.scr;
int itop = top + scr, ibot = bot + scr;
Line temp;
#if SIXEL_PATCH
ImageList *im, *next;
#endif // SIXEL_PATCH
if (n <= 0)
return;
n = MIN(n, bot-top+1);
tsetdirt(top + scr, bot + scr);
tclearregion(0, bot-n+1, term.col-1, bot, 1);
for (i = bot; i >= top+n; i--) {
temp = term.line[i];
term.line[i] = term.line[i-n];
term.line[i-n] = temp;
}
#if SIXEL_PATCH
/* move images, if they are inside the scrolling region */
for (im = term.images; im; im = next) {
next = im->next;
if (im->y >= itop && im->y <= ibot) {
im->y += n;
if (im->y > ibot)
delete_image(im);
}
}
#endif // SIXEL_PATCH
if (sel.ob.x != -1 && sel.alt == IS_SET(MODE_ALTSCREEN))
selscroll(top, bot, n);
}
void
tresize(int col, int row)
{
int *bp;
#if KEYBOARDSELECT_PATCH
if (row != term.row || col != term.col)
win.mode ^= kbds_keyboardhandler(XK_Escape, NULL, 0, 1);
#endif // KEYBOARDSELECT_PATCH
term.dirty = xrealloc(term.dirty, row * sizeof(*term.dirty));
term.tabs = xrealloc(term.tabs, col * sizeof(*term.tabs));
if (col > term.col) {
bp = term.tabs + term.col;
memset(bp, 0, sizeof(*term.tabs) * (col - term.col));
while (--bp > term.tabs && !*bp)
/* nothing */ ;
for (bp += tabspaces; bp < term.tabs + col; bp += tabspaces)
*bp = 1;
}
if (IS_SET(MODE_ALTSCREEN))
tresizealt(col, row);
else
tresizedef(col, row);
}
void
tclearregion(int x1, int y1, int x2, int y2, int usecurattr)
{
int x, y;
/* regionselected() takes relative coordinates */
if (regionselected(x1, y1+term.scr, x2, y2+term.scr))
selclear();
for (y = y1; y <= y2; y++) {
term.dirty[y] = 1;
for (x = x1; x <= x2; x++)
tclearglyph(&term.line[y][x], usecurattr);
}
}
void
tnew(int col, int row)
{
int i, j;
for (i = 0; i < 2; i++) {
term.line = xmalloc(row * sizeof(Line));
for (j = 0; j < row; j++)
term.line[j] = xmalloc(col * sizeof(Glyph));
term.col = col, term.row = row;
tswapscreen();
}
term.dirty = xmalloc(row * sizeof(*term.dirty));
term.tabs = xmalloc(col * sizeof(*term.tabs));
for (i = 0; i < HISTSIZE; i++)
term.hist[i] = xmalloc(col * sizeof(Glyph));
treset();
}
void
tdeletechar(int n)
{
int src, dst, size;
Line line;
if (n <= 0)
return;
dst = term.c.x;
src = MIN(term.c.x + n, term.col);
size = term.col - src;
if (size > 0) { /* otherwise src would point beyond the array
https://stackoverflow.com/questions/29844298 */
line = term.line[term.c.y];
memmove(&line[dst], &line[src], size * sizeof(Glyph));
}
tclearregion(dst + size, term.c.y, term.col - 1, term.c.y, 1);
}
void
tinsertblank(int n)
{
int src, dst, size;
Line line;
if (n <= 0)
return;
dst = MIN(term.c.x + n, term.col);
src = term.c.x;
size = term.col - dst;
if (size > 0) { /* otherwise dst would point beyond the array */
line = term.line[term.c.y];
memmove(&line[dst], &line[src], size * sizeof(Glyph));
}
tclearregion(src, term.c.y, dst - 1, term.c.y, 1);
}
int
tlinelen(Line line)
{
int i = term.col - 1;
/* We are using a different algorithm on the alt screen because an
* application might use spaces to clear the screen and in that case it is
* impossible to find the end of the line when every cell has the ATTR_SET
* attribute. The second algorithm is more accurate on the main screen and
* and we can use it there. */
if (IS_SET(MODE_ALTSCREEN))
for (; i >= 0 && !(line[i].mode & ATTR_WRAP) && line[i].u == ' '; i--);
else
for (; i >= 0 && !(line[i].mode & (ATTR_SET | ATTR_WRAP)); i--);
return i + 1;
}
int
tiswrapped(Line line)
{
int len = tlinelen(line);
return len > 0 && (line[len - 1].mode & ATTR_WRAP);
}
char *
tgetglyphs(char *buf, const Glyph *gp, const Glyph *lgp)
{
while (gp <= lgp)
if (gp->mode & ATTR_WDUMMY) {
gp++;
} else {
buf += utf8encode((gp++)->u, buf);
}
return buf;
}
size_t
tgetline(char *buf, const Glyph *fgp)
{
char *ptr;
const Glyph *lgp = &fgp[term.col - 1];
while (lgp > fgp && !(lgp->mode & (ATTR_SET | ATTR_WRAP)))
lgp--;
ptr = tgetglyphs(buf, fgp, lgp);
if (!(lgp->mode & ATTR_WRAP))
*(ptr++) = '\n';
return ptr - buf;
}
int
regionselected(int x1, int y1, int x2, int y2)
{
if (sel.ob.x == -1 || sel.mode == SEL_EMPTY ||
sel.alt != IS_SET(MODE_ALTSCREEN) || sel.nb.y > y2 || sel.ne.y < y1)
return 0;
return (sel.type == SEL_RECTANGULAR) ? sel.nb.x <= x2 && sel.ne.x >= x1
: (sel.nb.y != y2 || sel.nb.x <= x2) &&
(sel.ne.y != y1 || sel.ne.x >= x1);
}
int
selected(int x, int y)
{
return regionselected(x, y, x, y);
}
void
selsnap(int *x, int *y, int direction)
{
int newx, newy;
int rtop = 0, rbot = term.row - 1;
int delim, prevdelim, maxlen;
const Glyph *gp, *prevgp;
if (!IS_SET(MODE_ALTSCREEN))
rtop += -term.histf + term.scr, rbot += term.scr;
switch (sel.snap) {
case SNAP_WORD:
/*
* Snap around if the word wraps around at the end or
* beginning of a line.
*/
maxlen = (TLINE(*y)[term.col-2].mode & ATTR_WRAP) ? term.col-1 : term.col;
LIMIT(*x, 0, maxlen - 1);
prevgp = &TLINE(*y)[*x];
prevdelim = ISDELIM(prevgp->u);
for (;;) {
newx = *x + direction;
newy = *y;
if (!BETWEEN(newx, 0, maxlen - 1)) {
newy += direction;
if (!BETWEEN(newy, rtop, rbot))
break;
if (!tiswrapped(TLINE(direction > 0 ? *y : newy)))
break;
maxlen = (TLINE(newy)[term.col-2].mode & ATTR_WRAP) ? term.col-1 : term.col;
newx = direction > 0 ? 0 : maxlen - 1;
}
gp = &TLINE(newy)[newx];
delim = ISDELIM(gp->u);
if (!(gp->mode & ATTR_WDUMMY) && (delim != prevdelim
|| (delim && gp->u != prevgp->u)))
break;
*x = newx;
*y = newy;
if (!(gp->mode & ATTR_WDUMMY)) {
prevgp = gp;
prevdelim = delim;
}
}
break;
case SNAP_LINE:
/*
* Snap around if the the previous line or the current one
* has set ATTR_WRAP at its end. Then the whole next or
* previous line will be selected.
*/
*x = (direction < 0) ? 0 : term.col - 1;
if (direction < 0) {
for (; *y > rtop; *y -= 1) {
if (!tiswrapped(TLINE(*y-1)))
break;
}
} else if (direction > 0) {
for (; *y < rbot; *y += 1) {
if (!tiswrapped(TLINE(*y)))
break;
}
}
break;
}
}
void
selscroll(int top, int bot, int n)
{
/* turn absolute coordinates into relative */
top += term.scr, bot += term.scr;
if (BETWEEN(sel.nb.y, top, bot) != BETWEEN(sel.ne.y, top, bot)) {
selclear();
} else if (BETWEEN(sel.nb.y, top, bot)) {
selmove(n);
if (sel.nb.y < top || sel.ne.y > bot)
selclear();
}
}
void
tswapscreen(void)
{
static Line *altline;
static int altcol, altrow;
Line *tmpline = term.line;
int tmpcol = term.col, tmprow = term.row;
#if SIXEL_PATCH
ImageList *im = term.images;
#endif // SIXEL_PATCH
term.line = altline;
term.col = altcol, term.row = altrow;
altline = tmpline;
altcol = tmpcol, altrow = tmprow;
term.mode ^= MODE_ALTSCREEN;
#if SIXEL_PATCH
term.images = term.images_alt;
term.images_alt = im;
#endif // SIXEL_PATCH
}
char *
getsel(void)
{
char *str, *ptr;
int y, lastx, linelen;
const Glyph *gp, *lgp;
if (sel.ob.x == -1 || sel.alt != IS_SET(MODE_ALTSCREEN))
return NULL;
str = xmalloc((term.col + 1) * (sel.ne.y - sel.nb.y + 1) * UTF_SIZ);
ptr = str;
/* append every set & selected glyph to the selection */
for (y = sel.nb.y; y <= sel.ne.y; y++) {
Line line = TLINE(y);
if ((linelen = tlinelen(line)) == 0) {
*ptr++ = '\n';
continue;
}
if (sel.type == SEL_RECTANGULAR) {
gp = &line[sel.nb.x];
lastx = sel.ne.x;
} else {
gp = &line[sel.nb.y == y ? sel.nb.x : 0];
lastx = (sel.ne.y == y) ? sel.ne.x : term.col-1;
}
lgp = &line[MIN(lastx, linelen-1)];
ptr = tgetglyphs(ptr, gp, lgp);
/*
* Copy and pasting of line endings is inconsistent
* in the inconsistent terminal and GUI world.
* The best solution seems like to produce '\n' when
* something is copied from st and convert '\n' to
* '\r', when something to be pasted is received by
* st.
* FIXME: Fix the computer world.
*/
if ((y < sel.ne.y || lastx >= linelen) &&
(!(lgp->mode & ATTR_WRAP) || sel.type == SEL_RECTANGULAR))
*ptr++ = '\n';
}
*ptr = '\0';
return str;
}
void
tdumpline(int n)
{
char str[(term.col + 1) * UTF_SIZ];
tprinter(str, tgetline(str, &term.line[n][0]));
}

44
st-flexipatch/patch/reflow.h Normal file
View File

@@ -0,0 +1,44 @@
#define TLINE(y) ( \
(y) < term.scr ? term.hist[(term.histi + (y) - term.scr + 1 + HISTSIZE) % HISTSIZE] \
: term.line[(y) - term.scr] \
)
#define TLINEABS(y) ( \
(y) < 0 ? term.hist[(term.histi + (y) + 1 + HISTSIZE) % HISTSIZE] : term.line[(y)] \
)
#define UPDATEWRAPNEXT(alt, col) do { \
if ((term.c.state & CURSOR_WRAPNEXT) && term.c.x + term.wrapcwidth[alt] < col) { \
term.c.x += term.wrapcwidth[alt]; \
term.c.state &= ~CURSOR_WRAPNEXT; \
} \
} while (0);
static int tiswrapped(Line line);
static size_t tgetline(char *, const Glyph *);
static inline int regionselected(int, int, int, int);
static void tloaddefscreen(int, int);
static void tloadaltscreen(int, int);
static void selmove(int);
static inline void tclearglyph(Glyph *, int);
static void treflow(int, int);
static void rscrolldown(int);
static void tresizedef(int, int);
static void tresizealt(int, int);
void kscrolldown(const Arg *);
void kscrollup(const Arg *);
static void tscrollup(int, int, int, int);
static void tclearregion(int, int, int, int, int);
static void tdeletechar(int);
static int tlinelen(Line len);
static char * tgetglyphs(char *buf, const Glyph *gp, const Glyph *lgp);
static void selscroll(int, int, int);
typedef struct {
uint b;
uint mask;
void (*func)(const Arg *);
const Arg arg;
} MouseKey;
extern MouseKey mkeys[];

19
st-flexipatch/patch/rightclicktoplumb_st.c Normal file
View File

@@ -0,0 +1,19 @@
#if defined(__OpenBSD__)
#include <sys/sysctl.h>
#endif
int
subprocwd(char *path)
{
#if defined(__linux)
if (snprintf(path, PATH_MAX, "/proc/%d/cwd", pid) < 0)
return -1;
return 0;
#elif defined(__OpenBSD__)
size_t sz = PATH_MAX;
int name[3] = {CTL_KERN, KERN_PROC_CWD, pid};
if (sysctl(name, 3, path, &sz, 0, 0) == -1)
return -1;
return 0;
#endif
}

1
st-flexipatch/patch/rightclicktoplumb_st.h Normal file
View File

@@ -0,0 +1 @@
int subprocwd(char *);

25
st-flexipatch/patch/rightclicktoplumb_x.c Normal file
View File

@@ -0,0 +1,25 @@
#include <sys/wait.h>
void
plumb(char *sel)
{
if (sel == NULL)
return;
char cwd[PATH_MAX];
pid_t child;
if (subprocwd(cwd) != 0)
return;
switch (child = fork()) {
case -1:
return;
case 0:
if (chdir(cwd) != 0)
exit(1);
if (execvp(plumb_cmd, (char *const []){plumb_cmd, sel, 0}) == -1)
exit(1);
exit(0);
}
}

1
st-flexipatch/patch/rightclicktoplumb_x.h Normal file
View File

@@ -0,0 +1 @@
void plumb(char *);

55
st-flexipatch/patch/scrollback.c Normal file
View File

@@ -0,0 +1,55 @@
void
kscrolldown(const Arg* a)
{
int n = a->i;
if (n < 0)
n = term.row + n;
if (n > term.scr)
n = term.scr;
if (term.scr > 0) {
term.scr -= n;
selscroll(0, -n);
tfulldirt();
}
#if SIXEL_PATCH
scroll_images(-1*n);
#endif // SIXEL_PATCH
#if OPENURLONCLICK_PATCH
if (n > 0)
restoremousecursor();
#endif // OPENURLONCLICK_PATCH
}
void
kscrollup(const Arg* a)
{
int n = a->i;
if (n < 0)
n = term.row + n;
if (term.scr + n > term.histn)
n = term.histn - term.scr;
if (!n)
return;
if (term.scr <= HISTSIZE-n) {
term.scr += n;
selscroll(0, n);
tfulldirt();
}
#if SIXEL_PATCH
scroll_images(n);
#endif // SIXEL_PATCH
#if OPENURLONCLICK_PATCH
if (n > 0)
restoremousecursor();
#endif // OPENURLONCLICK_PATCH
}

17
st-flexipatch/patch/scrollback.h Normal file
View File

@@ -0,0 +1,17 @@
#define TLINE(y) ((y) < term.scr ? term.hist[((y) + term.histi - \
term.scr + HISTSIZE + 1) % HISTSIZE] : \
term.line[(y) - term.scr])
void kscrolldown(const Arg *);
void kscrollup(const Arg *);
#if SCROLLBACK_MOUSE_PATCH || SCROLLBACK_MOUSE_ALTSCREEN_PATCH
typedef struct {
uint b;
uint mask;
void (*func)(const Arg *);
const Arg arg;
} MouseKey;
extern MouseKey mkeys[];
#endif // SCROLLBACK_MOUSE_PATCH / SCROLLBACK_MOUSE_ALTSCREEN_PATCH

50
st-flexipatch/patch/st_embedder_x.c Normal file
View File

@@ -0,0 +1,50 @@
static Window embed;
void
createnotify(XEvent *e)
{
XWindowChanges wc;
if (embed || e->xcreatewindow.override_redirect)
return;
embed = e->xcreatewindow.window;
XReparentWindow(xw.dpy, embed, xw.win, 0, 0);
XSelectInput(xw.dpy, embed, PropertyChangeMask | StructureNotifyMask | EnterWindowMask);
XMapWindow(xw.dpy, embed);
sendxembed(XEMBED_EMBEDDED_NOTIFY, 0, xw.win, 0);
wc.width = win.w;
wc.height = win.h;
XConfigureWindow(xw.dpy, embed, CWWidth | CWHeight, &wc);
XSetInputFocus(xw.dpy, embed, RevertToParent, CurrentTime);
}
void
destroynotify(XEvent *e)
{
visibility(e);
if (embed == e->xdestroywindow.window) {
focus(e);
}
}
void
sendxembed(long msg, long detail, long d1, long d2)
{
XEvent e = { 0 };
e.xclient.window = embed;
e.xclient.type = ClientMessage;
e.xclient.message_type = xw.xembed;
e.xclient.format = 32;
e.xclient.data.l[0] = CurrentTime;
e.xclient.data.l[1] = msg;
e.xclient.data.l[2] = detail;
e.xclient.data.l[3] = d1;
e.xclient.data.l[4] = d2;
XSendEvent(xw.dpy, embed, False, NoEventMask, &e);
}

7
st-flexipatch/patch/st_embedder_x.h Normal file
View File

@@ -0,0 +1,7 @@
#define XEMBED_EMBEDDED_NOTIFY 0
#define XEMBED_WINDOW_ACTIVATE 1
#define XEMBED_FOCUS_CURRENT 0
static void createnotify(XEvent *e);
static void destroynotify(XEvent *e);
static void sendxembed(long msg, long detail, long d1, long d2);

32
st-flexipatch/patch/st_include.c Normal file
View File

@@ -0,0 +1,32 @@
/* Patches */
#if COPYURL_PATCH || COPYURL_HIGHLIGHT_SELECTED_URLS_PATCH
#include "copyurl.c"
#endif
#if EXTERNALPIPE_PATCH
#include "externalpipe.c"
#endif
#if ISO14755_PATCH
#include "iso14755.c"
#endif
#if REFLOW_PATCH && KEYBOARDSELECT_PATCH
#include "keyboardselect_reflow_st.c"
#elif KEYBOARDSELECT_PATCH
#include "keyboardselect_st.c"
#endif
#if RIGHTCLICKTOPLUMB_PATCH
#include "rightclicktoplumb_st.c"
#endif
#if NEWTERM_PATCH
#include "newterm.c"
#endif
#if REFLOW_PATCH
#include "reflow.c"
#elif SCROLLBACK_PATCH || SCROLLBACK_MOUSE_PATCH || SCROLLBACK_MOUSE_ALTSCREEN_PATCH
#include "scrollback.c"
#endif
#if SYNC_PATCH
#include "sync.c"
#endif
#if OSC7_PATCH
#include "osc7.c"
#endif

35
st-flexipatch/patch/st_include.h Normal file
View File

@@ -0,0 +1,35 @@
/* Patches */
#if COPYURL_PATCH || COPYURL_HIGHLIGHT_SELECTED_URLS_PATCH
#include "copyurl.h"
#endif
#if EXTERNALPIPE_PATCH
#include "externalpipe.h"
#endif
#if ISO14755_PATCH
#include "iso14755.h"
#endif
#if REFLOW_PATCH && KEYBOARDSELECT_PATCH
#include "keyboardselect_reflow_st.h"
#elif KEYBOARDSELECT_PATCH
#include "keyboardselect_st.h"
#endif
#if OPENURLONCLICK_PATCH
#include "openurlonclick.h"
#endif
#if RIGHTCLICKTOPLUMB_PATCH
#include "rightclicktoplumb_st.h"
#endif
#if NEWTERM_PATCH
#include "newterm.h"
#endif
#if REFLOW_PATCH
#include "reflow.h"
#elif SCROLLBACK_PATCH || SCROLLBACK_MOUSE_PATCH || SCROLLBACK_MOUSE_ALTSCREEN_PATCH
#include "scrollback.h"
#endif
#if SYNC_PATCH
#include "sync.h"
#endif
#if OSC7_PATCH
#include "osc7.h"
#endif

31
st-flexipatch/patch/sync.c Normal file
View File

@@ -0,0 +1,31 @@
#include <time.h>
struct timespec sutv;
static void
tsync_begin()
{
clock_gettime(CLOCK_MONOTONIC, &sutv);
su = 1;
}
static void
tsync_end()
{
su = 0;
}
int
tinsync(uint timeout)
{
struct timespec now;
if (su && !clock_gettime(CLOCK_MONOTONIC, &now)
&& TIMEDIFF(now, sutv) >= timeout)
su = 0;
return su;
}
int
ttyread_pending()
{
return twrite_aborted;
}

7
st-flexipatch/patch/sync.h Normal file
View File

@@ -0,0 +1,7 @@
static int su = 0;
static int twrite_aborted = 0;
static void tsync_begin();
static void tsync_end();
int tinsync(uint timeout);
int ttyread_pending();

58
st-flexipatch/patch/x_include.c Normal file
View File

@@ -0,0 +1,58 @@
/* Patches */
#if ALPHA_PATCH
#include "alpha.c"
#endif
#if BACKGROUND_IMAGE_PATCH
#include "background_image_x.c"
#endif
#if BOXDRAW_PATCH
#include "boxdraw.c"
#endif
#if DRAG_AND_DROP_PATCH
#include "drag-n-drop.c"
#endif
#if OPENCOPIED_PATCH
#include "opencopied.c"
#endif
#if FIXKEYBOARDINPUT_PATCH
#include "fixkeyboardinput.c"
#endif
#if FONT2_PATCH
#include "font2.c"
#endif
#if FULLSCREEN_PATCH
#include "fullscreen_x.c"
#endif
#if INVERT_PATCH
#include "invert.c"
#endif
#if REFLOW_PATCH && KEYBOARDSELECT_PATCH
#include "keyboardselect_reflow_x.c"
#elif KEYBOARDSELECT_PATCH
#include "keyboardselect_x.c"
#endif
#if NETWMICON_PATCH
#include "netwmicon.c"
#elif NETWMICON_FF_PATCH
#include "netwmicon_ff.c"
#elif NETWMICON_LEGACY_PATCH
#include "netwmicon_legacy.c"
#endif
#if OPEN_SELECTED_TEXT_PATCH
#include "openselectedtext.c"
#endif
#if OPENURLONCLICK_PATCH
#include "openurlonclick.c"
#endif
#if RIGHTCLICKTOPLUMB_PATCH
#include "rightclicktoplumb_x.c"
#endif
#if ST_EMBEDDER_PATCH
#include "st_embedder_x.c"
#endif
#if XRESOURCES_PATCH
#include "xresources.c"
#endif
#if OSC133_PATCH
#include "osc133.c"
#endif

52
st-flexipatch/patch/x_include.h Normal file
View File

@@ -0,0 +1,52 @@
/* Patches */
#if ALPHA_PATCH
#include "alpha.h"
#endif
#if BACKGROUND_IMAGE_PATCH
#include "background_image_x.h"
#endif
#if BOXDRAW_PATCH
#include "boxdraw.h"
#endif
#if DRAG_AND_DROP_PATCH
#include "drag-n-drop.h"
#endif
#if OPENCOPIED_PATCH
#include "opencopied.h"
#endif
#if FONT2_PATCH
#include "font2.h"
#endif
#if FULLSCREEN_PATCH
#include "fullscreen_x.h"
#endif
#if INVERT_PATCH
#include "invert.h"
#endif
#if REFLOW_PATCH && KEYBOARDSELECT_PATCH
#include "keyboardselect_reflow_st.h"
#include "keyboardselect_reflow_x.h"
#elif KEYBOARDSELECT_PATCH
#include "keyboardselect_x.h"
#endif
#if NETWMICON_LEGACY_PATCH
#include "netwmicon_icon.h"
#endif
#if NETWMICON_PATCH || NETWMICON_FF_PATCH || NETWMICON_LEGACY_PATCH
#include "netwmicon.h"
#endif
#if OPEN_SELECTED_TEXT_PATCH
#include "openselectedtext.h"
#endif
#if RIGHTCLICKTOPLUMB_PATCH
#include "rightclicktoplumb_x.h"
#endif
#if ST_EMBEDDER_PATCH
#include "st_embedder_x.h"
#endif
#if XRESOURCES_PATCH
#include "xresources.h"
#endif
#if OSC133_PATCH
#include "osc133.h"
#endif

182
st-flexipatch/patch/xresources.c Normal file
View File

@@ -0,0 +1,182 @@
int
resource_load(XrmDatabase db, char *name, enum resource_type rtype, void *dst)
{
char **sdst = dst;
int *idst = dst;
float *fdst = dst;
char fullname[256];
char fullclass[256];
char *type;
XrmValue ret;
snprintf(fullname, sizeof(fullname), "%s.%s",
opt_name ? opt_name : "st", name);
snprintf(fullclass, sizeof(fullclass), "%s.%s",
opt_class ? opt_class : "St", name);
fullname[sizeof(fullname) - 1] = fullclass[sizeof(fullclass) - 1] = '\0';
XrmGetResource(db, fullname, fullclass, &type, &ret);
if (ret.addr == NULL || strncmp("String", type, 64))
return 1;
switch (rtype) {
case STRING:
/* Note: this leaks memory */
*sdst = strdup(ret.addr);
break;
case INTEGER:
*idst = strtoul(ret.addr, NULL, 10);
break;
case FLOAT:
*fdst = strtof(ret.addr, NULL);
break;
}
return 0;
}
#if XRESOURCES_XDEFAULTS_PATCH
/* Returns an XrmDatabase that needs to be freed by the caller. */
static XrmDatabase
get_resources(Display *dpy)
{
/*******************************************************************/
/* Adapted from rxvt-unicode-9.31 rxvttoolkit.C get_resources() */
/*******************************************************************/
char *homedir = getenv("HOME");
char fname[1024];
char *displayResource, *xe;
XrmDatabase rdb1;
XrmDatabase database = XrmGetStringDatabase("");
/* For ordering, see for example http://www.faqs.org/faqs/Xt-FAQ/ Subject: 20 */
/* 6. System wide per application default file. */
/* Add in $XAPPLRESDIR/St only; not bothering with XUSERFILESEARCHPATH */
if ((xe = getenv("XAPPLRESDIR")) || (xe = "/etc/X11/app-defaults"))
{
snprintf(fname, sizeof(fname), "%s/%s", xe, "St");
if ((rdb1 = XrmGetFileDatabase(fname)))
XrmMergeDatabases(rdb1, &database);
}
/* 5. User's per application default file. None. */
/* 4. User's defaults file. */
if (homedir)
{
snprintf(fname, sizeof(fname), "%s/.Xdefaults", homedir);
if ((rdb1 = XrmGetFileDatabase(fname)))
XrmMergeDatabases(rdb1, &database);
}
/* Get any Xserver Resources (xrdb). */
displayResource = XResourceManagerString(dpy);
if (displayResource)
{
if ((rdb1 = XrmGetStringDatabase(displayResource)))
XrmMergeDatabases(rdb1, &database);
}
/* Get screen specific resources. */
displayResource = XScreenResourceString(ScreenOfDisplay(dpy, DefaultScreen(dpy)));
if (displayResource)
{
if ((rdb1 = XrmGetStringDatabase(displayResource)))
XrmMergeDatabases(rdb1, &database);
XFree(displayResource);
}
/* 3. User's per host defaults file. */
/* Add in XENVIRONMENT file */
if ((xe = getenv("XENVIRONMENT")) && (rdb1 = XrmGetFileDatabase(xe)))
XrmMergeDatabases(rdb1, &database);
else if (homedir)
{
struct utsname un;
if (!uname(&un))
{
snprintf(fname, sizeof(fname), "%s/.Xdefaults-%s", homedir, un.nodename);
if ((rdb1 = XrmGetFileDatabase(fname)))
XrmMergeDatabases(rdb1, &database);
}
}
return database;
}
void
config_init(Display *dpy)
{
XrmDatabase db;
ResourcePref *p;
XrmInitialize();
db = get_resources(dpy);
for (p = resources; p < resources + LEN(resources); p++)
resource_load(db, p->name, p->type, p->dst);
XrmDestroyDatabase(db);
}
#else // !XRESOURCES_XDEFAULTS_PATCH
void
config_init(Display *dpy)
{
char *resm;
XrmDatabase db;
ResourcePref *p;
XrmInitialize();
resm = XResourceManagerString(dpy);
if (!resm)
return;
db = XrmGetStringDatabase(resm);
if (!db)
return;
for (p = resources; p < resources + LEN(resources); p++)
resource_load(db, p->name, p->type, p->dst);
XrmDestroyDatabase(db);
}
#endif // XRESOURCES_XDEFAULTS_PATCH
#if XRESOURCES_RELOAD_PATCH
void
reload_config(int sig)
{
/* Recreate a Display object to have up to date Xresources entries */
Display *dpy;
if (!(dpy = XOpenDisplay(NULL)))
die("Can't open display\n");
config_init(dpy);
xloadcols();
/* nearly like zoomabs() */
xunloadfonts();
xloadfonts(font, 0); /* font <- config_init() */
#if FONT2_PATCH
xloadsparefonts();
#endif // FONT2_PATCH
cresize(0, 0);
redraw();
xhints();
XCloseDisplay(dpy);
}
#endif // XRESOURCES_RELOAD_PATCH

20
st-flexipatch/patch/xresources.h Normal file
View File

@@ -0,0 +1,20 @@
#include <X11/Xresource.h>
#if XRESOURCES_XDEFAULTS_PATCH
#include <sys/utsname.h>
#endif // XRESOURCES_XDEFAULTS_PATCH
/* Xresources preferences */
enum resource_type {
STRING = 0,
INTEGER = 1,
FLOAT = 2
};
typedef struct {
char *name;
enum resource_type type;
void *dst;
} ResourcePref;
int resource_load(XrmDatabase, char *, enum resource_type, void *);
void config_init(Display *dpy);