diff options
Diffstat (limited to 'keep/manual-programs/suckless/st-flexipatch/patch')
65 files changed, 5849 insertions, 0 deletions
diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/alpha.c b/keep/manual-programs/suckless/st-flexipatch/patch/alpha.c new file mode 100644 index 0000000..146bf4b --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/alpha.c @@ -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 diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/alpha.h b/keep/manual-programs/suckless/st-flexipatch/patch/alpha.h new file mode 100644 index 0000000..2d01830 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/alpha.h @@ -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 diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/background_image_x.c b/keep/manual-programs/suckless/st-flexipatch/patch/background_image_x.c new file mode 100644 index 0000000..3bbb189 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/background_image_x.c @@ -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 diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/background_image_x.h b/keep/manual-programs/suckless/st-flexipatch/patch/background_image_x.h new file mode 100644 index 0000000..e96edd2 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/background_image_x.h @@ -0,0 +1,6 @@ +#include <arpa/inet.h> + +static void updatexy(void); +static XImage *loadff(const char *); +static void bginit(); +static void reload_image(); diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/boxdraw.c b/keep/manual-programs/suckless/st-flexipatch/patch/boxdraw.c new file mode 100644 index 0000000..3cc5b51 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/boxdraw.c @@ -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); + } + } +}
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/boxdraw.h b/keep/manual-programs/suckless/st-flexipatch/patch/boxdraw.h new file mode 100644 index 0000000..12df637 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/boxdraw.h @@ -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) */ +};
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/copyurl.c b/keep/manual-programs/suckless/st-flexipatch/patch/copyurl.c new file mode 100644 index 0000000..90d96db --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/copyurl.c @@ -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
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/copyurl.h b/keep/manual-programs/suckless/st-flexipatch/patch/copyurl.h new file mode 100644 index 0000000..88059af --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/copyurl.h @@ -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
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/drag-n-drop.c b/keep/manual-programs/suckless/st-flexipatch/patch/drag-n-drop.c new file mode 100644 index 0000000..917a9aa --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/drag-n-drop.c @@ -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); + } +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/drag-n-drop.h b/keep/manual-programs/suckless/st-flexipatch/patch/drag-n-drop.h new file mode 100644 index 0000000..ee8e82b --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/drag-n-drop.h @@ -0,0 +1,5 @@ +static void xdndenter(XEvent *); +static void xdndpos(XEvent *); +static void xdnddrop(XEvent *); +static void xdndsel(XEvent *); +static void xdndpastedata(char *); diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/externalpipe.c b/keep/manual-programs/suckless/st-flexipatch/patch/externalpipe.c new file mode 100644 index 0000000..8328c37 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/externalpipe.c @@ -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
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/externalpipe.h b/keep/manual-programs/suckless/st-flexipatch/patch/externalpipe.h new file mode 100644 index 0000000..764504b --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/externalpipe.h @@ -0,0 +1,4 @@ +void externalpipe(const Arg *); +#if EXTERNALPIPEIN_PATCH +void externalpipein(const Arg *); +#endif // EXTERNALPIPEIN_PATCH
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/fixkeyboardinput.c b/keep/manual-programs/suckless/st-flexipatch/patch/fixkeyboardinput.c new file mode 100644 index 0000000..75f8f40 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/fixkeyboardinput.c @@ -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}, +};
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/font2.c b/keep/manual-programs/suckless/st-flexipatch/patch/font2.c new file mode 100644 index 0000000..9fc0e2d --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/font2.c @@ -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); + } +}
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/font2.h b/keep/manual-programs/suckless/st-flexipatch/patch/font2.h new file mode 100644 index 0000000..c0f9ff5 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/font2.h @@ -0,0 +1,2 @@ +static int xloadsparefont(FcPattern *, int); +static void xloadsparefonts(void);
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/fullscreen_x.c b/keep/manual-programs/suckless/st-flexipatch/patch/fullscreen_x.c new file mode 100644 index 0000000..3fa65f7 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/fullscreen_x.c @@ -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); +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/fullscreen_x.h b/keep/manual-programs/suckless/st-flexipatch/patch/fullscreen_x.h new file mode 100644 index 0000000..28a833b --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/fullscreen_x.h @@ -0,0 +1 @@ +static void fullscreen(const Arg *arg); diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/invert.c b/keep/manual-programs/suckless/st-flexipatch/patch/invert.c new file mode 100644 index 0000000..2260b5d --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/invert.c @@ -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; +}
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/invert.h b/keep/manual-programs/suckless/st-flexipatch/patch/invert.h new file mode 100644 index 0000000..0b0931f --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/invert.h @@ -0,0 +1 @@ +static void invert(const Arg *);
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/iso14755.c b/keep/manual-programs/suckless/st-flexipatch/patch/iso14755.c new file mode 100644 index 0000000..a2fbd79 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/iso14755.c @@ -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); +}
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/iso14755.h b/keep/manual-programs/suckless/st-flexipatch/patch/iso14755.h new file mode 100644 index 0000000..45a3d7a --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/iso14755.h @@ -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 *);
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_reflow.txt b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_reflow.txt new file mode 100644 index 0000000..8dd6c49 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_reflow.txt @@ -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 diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_reflow_st.c b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_reflow_st.c new file mode 100644 index 0000000..b532557 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_reflow_st.c @@ -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; +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_reflow_st.h b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_reflow_st.h new file mode 100644 index 0000000..c840af8 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_reflow_st.h @@ -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); diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_reflow_x.c b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_reflow_x.c new file mode 100644 index 0000000..c8a39a2 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_reflow_x.c @@ -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); +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_reflow_x.h b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_reflow_x.h new file mode 100644 index 0000000..6893013 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_reflow_x.h @@ -0,0 +1,3 @@ +void keyboard_select(const Arg *); +void searchforward(const Arg *); +void searchbackward(const Arg *); diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_st.c b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_st.c new file mode 100644 index 0000000..7599d9d --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_st.c @@ -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; +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_st.h b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_st.h new file mode 100644 index 0000000..3fa1ad7 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_st.h @@ -0,0 +1,2 @@ +void toggle_winmode(int); +int trt_kbdselect(KeySym, char *, int);
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_x.c b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_x.c new file mode 100644 index 0000000..44cbe64 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_x.c @@ -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); +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_x.h b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_x.h new file mode 100644 index 0000000..6b1241a --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/keyboardselect_x.h @@ -0,0 +1,2 @@ +void toggle_winmode(int); +void keyboard_select(const Arg *);
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/netwmicon.c b/keep/manual-programs/suckless/st-flexipatch/patch/netwmicon.c new file mode 100644 index 0000000..6ae0533 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/netwmicon.c @@ -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); + } +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/netwmicon.h b/keep/manual-programs/suckless/st-flexipatch/patch/netwmicon.h new file mode 100644 index 0000000..99afb44 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/netwmicon.h @@ -0,0 +1 @@ +static void setnetwmicon(void); diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/netwmicon_ff.c b/keep/manual-programs/suckless/st-flexipatch/patch/netwmicon_ff.c new file mode 100644 index 0000000..3bb9ed9 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/netwmicon_ff.c @@ -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); + } +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/netwmicon_icon.h b/keep/manual-programs/suckless/st-flexipatch/patch/netwmicon_icon.h new file mode 100644 index 0000000..5e9c654 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/netwmicon_icon.h @@ -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, +};
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/netwmicon_legacy.c b/keep/manual-programs/suckless/st-flexipatch/patch/netwmicon_legacy.c new file mode 100644 index 0000000..9a3bd36 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/netwmicon_legacy.c @@ -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)); +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/newterm.c b/keep/manual-programs/suckless/st-flexipatch/patch/newterm.c new file mode 100644 index 0000000..a7430ce --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/newterm.c @@ -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); + } + } +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/newterm.h b/keep/manual-programs/suckless/st-flexipatch/patch/newterm.h new file mode 100644 index 0000000..8073349 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/newterm.h @@ -0,0 +1 @@ +void newterm(const Arg *); diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/opencopied.c b/keep/manual-programs/suckless/st-flexipatch/patch/opencopied.c new file mode 100644 index 0000000..9b07c58 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/opencopied.c @@ -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); +}
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/opencopied.h b/keep/manual-programs/suckless/st-flexipatch/patch/opencopied.h new file mode 100644 index 0000000..3734ac7 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/opencopied.h @@ -0,0 +1 @@ +void opencopied(const Arg *);
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/openselectedtext.c b/keep/manual-programs/suckless/st-flexipatch/patch/openselectedtext.c new file mode 100644 index 0000000..42d40e2 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/openselectedtext.c @@ -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); +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/openselectedtext.h b/keep/manual-programs/suckless/st-flexipatch/patch/openselectedtext.h new file mode 100644 index 0000000..3dccbc6 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/openselectedtext.h @@ -0,0 +1,3 @@ +#include <sys/wait.h> + +static void selopen(const Arg *); diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/openurlonclick.c b/keep/manual-programs/suckless/st-flexipatch/patch/openurlonclick.c new file mode 100644 index 0000000..54b1a02 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/openurlonclick.c @@ -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); + } +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/openurlonclick.h b/keep/manual-programs/suckless/st-flexipatch/patch/openurlonclick.h new file mode 100644 index 0000000..5aa09de --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/openurlonclick.h @@ -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); diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/osc133.c b/keep/manual-programs/suckless/st-flexipatch/patch/osc133.c new file mode 100644 index 0000000..6baa82a --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/osc133.c @@ -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 })); +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/osc133.h b/keep/manual-programs/suckless/st-flexipatch/patch/osc133.h new file mode 100644 index 0000000..f5a6c45 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/osc133.h @@ -0,0 +1 @@ +static void scrolltoprompt(const Arg *); diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/osc7.c b/keep/manual-programs/suckless/st-flexipatch/patch/osc7.c new file mode 100644 index 0000000..39ac0a0 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/osc7.c @@ -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; +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/osc7.h b/keep/manual-programs/suckless/st-flexipatch/patch/osc7.h new file mode 100644 index 0000000..965add8 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/osc7.h @@ -0,0 +1 @@ +static int osc7parsecwd(const char *); diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/reflow.c b/keep/manual-programs/suckless/st-flexipatch/patch/reflow.c new file mode 100644 index 0000000..dac7b9d --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/reflow.c @@ -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])); +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/reflow.h b/keep/manual-programs/suckless/st-flexipatch/patch/reflow.h new file mode 100644 index 0000000..ec28375 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/reflow.h @@ -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[]; diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/rightclicktoplumb_st.c b/keep/manual-programs/suckless/st-flexipatch/patch/rightclicktoplumb_st.c new file mode 100644 index 0000000..c60b946 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/rightclicktoplumb_st.c @@ -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 +}
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/rightclicktoplumb_st.h b/keep/manual-programs/suckless/st-flexipatch/patch/rightclicktoplumb_st.h new file mode 100644 index 0000000..98e42ab --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/rightclicktoplumb_st.h @@ -0,0 +1 @@ +int subprocwd(char *);
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/rightclicktoplumb_x.c b/keep/manual-programs/suckless/st-flexipatch/patch/rightclicktoplumb_x.c new file mode 100644 index 0000000..674b602 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/rightclicktoplumb_x.c @@ -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); + } +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/rightclicktoplumb_x.h b/keep/manual-programs/suckless/st-flexipatch/patch/rightclicktoplumb_x.h new file mode 100644 index 0000000..d0c8b88 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/rightclicktoplumb_x.h @@ -0,0 +1 @@ +void plumb(char *);
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/scrollback.c b/keep/manual-programs/suckless/st-flexipatch/patch/scrollback.c new file mode 100644 index 0000000..2644cfe --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/scrollback.c @@ -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 +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/scrollback.h b/keep/manual-programs/suckless/st-flexipatch/patch/scrollback.h new file mode 100644 index 0000000..08940f0 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/scrollback.h @@ -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 diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/st_embedder_x.c b/keep/manual-programs/suckless/st-flexipatch/patch/st_embedder_x.c new file mode 100644 index 0000000..c73c389 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/st_embedder_x.c @@ -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); +} diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/st_embedder_x.h b/keep/manual-programs/suckless/st-flexipatch/patch/st_embedder_x.h new file mode 100644 index 0000000..6910fb9 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/st_embedder_x.h @@ -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);
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/st_include.c b/keep/manual-programs/suckless/st-flexipatch/patch/st_include.c new file mode 100644 index 0000000..193cc61 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/st_include.c @@ -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 diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/st_include.h b/keep/manual-programs/suckless/st-flexipatch/patch/st_include.h new file mode 100644 index 0000000..e75985a --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/st_include.h @@ -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 diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/sync.c b/keep/manual-programs/suckless/st-flexipatch/patch/sync.c new file mode 100644 index 0000000..a0a815c --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/sync.c @@ -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; +}
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/sync.h b/keep/manual-programs/suckless/st-flexipatch/patch/sync.h new file mode 100644 index 0000000..6c2ebe7 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/sync.h @@ -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();
\ No newline at end of file diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/x_include.c b/keep/manual-programs/suckless/st-flexipatch/patch/x_include.c new file mode 100644 index 0000000..5a0ba58 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/x_include.c @@ -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 diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/x_include.h b/keep/manual-programs/suckless/st-flexipatch/patch/x_include.h new file mode 100644 index 0000000..ed10e8c --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/x_include.h @@ -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 diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/xresources.c b/keep/manual-programs/suckless/st-flexipatch/patch/xresources.c new file mode 100644 index 0000000..a294795 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/xresources.c @@ -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 diff --git a/keep/manual-programs/suckless/st-flexipatch/patch/xresources.h b/keep/manual-programs/suckless/st-flexipatch/patch/xresources.h new file mode 100644 index 0000000..91d5093 --- /dev/null +++ b/keep/manual-programs/suckless/st-flexipatch/patch/xresources.h @@ -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); |