From c78eeffd09557c6f04ab9193207ead6c8a2b3acc Mon Sep 17 00:00:00 2001 From: DarthMooMancer Date: Sat, 6 Sep 2025 01:23:36 -0400 Subject: [PATCH] fix: dwm border fix by adding in alpha to opaque patch feat: st now has alpha and ligatures --- .config/suckless/st/Makefile | 8 +- .config/suckless/st/config.h | 2 + .config/suckless/st/hb.c | 125 ++++ .config/suckless/st/hb.h | 14 + .../st/patches/st-alpha-20240814-a0274bc.diff | 103 +++ .../st-ligatures-alpha-scrollback-0.9.2.diff | 592 ++++++++++++++++++ .config/suckless/st/st.c | 3 +- .config/suckless/st/st.h | 3 +- .config/suckless/st/win.h | 2 +- .config/suckless/st/x.c | 339 +++++----- 10 files changed, 1036 insertions(+), 155 deletions(-) create mode 100644 .config/suckless/st/hb.c create mode 100644 .config/suckless/st/hb.h create mode 100644 .config/suckless/st/patches/st-alpha-20240814-a0274bc.diff create mode 100644 .config/suckless/st/patches/st-ligatures-alpha-scrollback-0.9.2.diff diff --git a/.config/suckless/st/Makefile b/.config/suckless/st/Makefile index a93ba8c..0cbb083 100644 --- a/.config/suckless/st/Makefile +++ b/.config/suckless/st/Makefile @@ -8,10 +8,11 @@ X11LIB = /usr/X11R6/lib PKG_CONFIG = pkg-config # includes and libs -INCS = $(shell pkg-config --cflags x11 fontconfig freetype2) # -I$(X11INC) +INCS = $(shell pkg-config --cflags x11 fontconfig freetype2 harfbuzz) # -I$(X11INC) LIBS = -L$(X11LIB) -lm -lrt -lX11 -lutil -lXft \ `$(PKG_CONFIG) --libs fontconfig` \ - `$(PKG_CONFIG) --libs freetype2` + `$(PKG_CONFIG) --cflags freetype2` \ + `$(PKG_CONFIG) --libs harfbuzz` # flags STCPPFLAGS = -D_XOPEN_SOURCE=600 @@ -21,7 +22,7 @@ STLDFLAGS = $(LIBS) $(LDFLAGS) # compiler and linker CC = gcc -SRC = st.c x.c +SRC = st.c x.c hb.c OBJ = $(SRC:.c=.o) all: st @@ -31,6 +32,7 @@ all: st st.o: config.h st.h win.h x.o: arg.h config.h st.h win.h +hb.o: st.h $(OBJ): config.h diff --git a/.config/suckless/st/config.h b/.config/suckless/st/config.h index 526dd2c..e837e2a 100644 --- a/.config/suckless/st/config.h +++ b/.config/suckless/st/config.h @@ -70,6 +70,8 @@ static int bellvolume = 0; char *termname = "st-256color"; unsigned int tabspaces = 8; +float alpha = 0.8; + static const char *colorname[] = { /* 8 normal colors */ "#343f44", // black diff --git a/.config/suckless/st/hb.c b/.config/suckless/st/hb.c new file mode 100644 index 0000000..99412c8 --- /dev/null +++ b/.config/suckless/st/hb.c @@ -0,0 +1,125 @@ +#include +#include +#include +#include +#include +#include +#include + +#include "st.h" +#include "hb.h" + +#define FEATURE(c1,c2,c3,c4) { .tag = HB_TAG(c1,c2,c3,c4), .value = 1, .start = HB_FEATURE_GLOBAL_START, .end = HB_FEATURE_GLOBAL_END } +#define BUFFER_STEP 256 + +hb_font_t *hbfindfont(XftFont *match); + +typedef struct { + XftFont *match; + hb_font_t *font; +} HbFontMatch; + +typedef struct { + size_t capacity; + HbFontMatch *fonts; +} HbFontCache; + +static HbFontCache hbfontcache = { 0, NULL }; + +typedef struct { + size_t capacity; + Rune *runes; +} RuneBuffer; + +static RuneBuffer hbrunebuffer = { 0, NULL }; + +/* + * Poplulate the array with a list of font features, wrapped in FEATURE macro, + * e. g. + * FEATURE('c', 'a', 'l', 't'), FEATURE('d', 'l', 'i', 'g') + */ +hb_feature_t features[] = { }; + +void +hbunloadfonts() +{ + for (int i = 0; i < hbfontcache.capacity; i++) { + hb_font_destroy(hbfontcache.fonts[i].font); + XftUnlockFace(hbfontcache.fonts[i].match); + } + + if (hbfontcache.fonts != NULL) { + free(hbfontcache.fonts); + hbfontcache.fonts = NULL; + } + hbfontcache.capacity = 0; +} + +hb_font_t * +hbfindfont(XftFont *match) +{ + for (int i = 0; i < hbfontcache.capacity; i++) { + if (hbfontcache.fonts[i].match == match) + return hbfontcache.fonts[i].font; + } + + /* Font not found in cache, caching it now. */ + hbfontcache.fonts = realloc(hbfontcache.fonts, sizeof(HbFontMatch) * (hbfontcache.capacity + 1)); + FT_Face face = XftLockFace(match); + hb_font_t *font = hb_ft_font_create(face, NULL); + if (font == NULL) + die("Failed to load Harfbuzz font."); + + hbfontcache.fonts[hbfontcache.capacity].match = match; + hbfontcache.fonts[hbfontcache.capacity].font = font; + hbfontcache.capacity += 1; + + return font; +} + +void hbtransform(HbTransformData *data, XftFont *xfont, const Glyph *glyphs, int start, int length) { + ushort mode = USHRT_MAX; + unsigned int glyph_count; + int rune_idx, glyph_idx, end = start + length; + + hb_font_t *font = hbfindfont(xfont); + if (font == NULL) + return; + + hb_buffer_t *buffer = hb_buffer_create(); + hb_buffer_set_direction(buffer, HB_DIRECTION_LTR); + hb_buffer_set_cluster_level(buffer, HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS); + + /* Resize the buffer if required length is larger. */ + if (hbrunebuffer.capacity < length) { + hbrunebuffer.capacity = (length / BUFFER_STEP + 1) * BUFFER_STEP; + hbrunebuffer.runes = realloc(hbrunebuffer.runes, hbrunebuffer.capacity * sizeof(Rune)); + } + + /* Fill buffer with codepoints. */ + for (rune_idx = 0, glyph_idx = start; glyph_idx < end; glyph_idx++, rune_idx++) { + hbrunebuffer.runes[rune_idx] = glyphs[glyph_idx].u; + mode = glyphs[glyph_idx].mode; + if (mode & ATTR_WDUMMY) + hbrunebuffer.runes[rune_idx] = 0x0020; + } + hb_buffer_add_codepoints(buffer, hbrunebuffer.runes, length, 0, length); + + /* Shape the segment. */ + hb_shape(font, buffer, features, sizeof(features)/sizeof(hb_feature_t)); + + /* Get new glyph info. */ + hb_glyph_info_t *info = hb_buffer_get_glyph_infos(buffer, &glyph_count); + hb_glyph_position_t *pos = hb_buffer_get_glyph_positions(buffer, &glyph_count); + + /* Fill the output. */ + data->buffer = buffer; + data->glyphs = info; + data->positions = pos; + data->count = glyph_count; +} + +void hbcleanup(HbTransformData *data) { + hb_buffer_destroy(data->buffer); + memset(data, 0, sizeof(HbTransformData)); +} diff --git a/.config/suckless/st/hb.h b/.config/suckless/st/hb.h new file mode 100644 index 0000000..3b0ef44 --- /dev/null +++ b/.config/suckless/st/hb.h @@ -0,0 +1,14 @@ +#include +#include +#include + +typedef struct { + hb_buffer_t *buffer; + hb_glyph_info_t *glyphs; + hb_glyph_position_t *positions; + unsigned int count; +} HbTransformData; + +void hbunloadfonts(); +void hbtransform(HbTransformData *, XftFont *, const Glyph *, int, int); +void hbcleanup(HbTransformData *); diff --git a/.config/suckless/st/patches/st-alpha-20240814-a0274bc.diff b/.config/suckless/st/patches/st-alpha-20240814-a0274bc.diff new file mode 100644 index 0000000..3f45175 --- /dev/null +++ b/.config/suckless/st/patches/st-alpha-20240814-a0274bc.diff @@ -0,0 +1,103 @@ +diff --git a/x.c b/x.c +index d73152b..f32fd6c 100644 +--- a/x.c ++++ b/x.c +@@ -105,6 +105,7 @@ typedef struct { + XSetWindowAttributes attrs; + int scr; + int isfixed; /* is fixed geometry? */ ++ int depth; /* bit depth */ + int l, t; /* left and top offset */ + int gm; /* geometry mask */ + } XWindow; +@@ -752,7 +753,7 @@ xresize(int col, int row) + + XFreePixmap(xw.dpy, xw.buf); + xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h, +- DefaultDepth(xw.dpy, xw.scr)); ++ xw.depth); + XftDrawChange(xw.draw, xw.buf); + xclear(0, 0, win.w, win.h); + +@@ -812,6 +813,10 @@ xloadcols(void) + else + die("could not allocate color %d\n", i); + } ++ ++ dc.col[defaultbg].color.alpha = (unsigned short)(0xffff * alpha); ++ dc.col[defaultbg].pixel &= 0x00FFFFFF; ++ dc.col[defaultbg].pixel |= (unsigned char)(0xff * alpha) << 24; + loaded = 1; + } + +@@ -842,6 +847,12 @@ xsetcolorname(int x, const char *name) + XftColorFree(xw.dpy, xw.vis, xw.cmap, &dc.col[x]); + dc.col[x] = ncolor; + ++ if (x == defaultbg) { ++ dc.col[defaultbg].color.alpha = (unsigned short)(0xffff * alpha); ++ dc.col[defaultbg].pixel &= 0x00FFFFFF; ++ dc.col[defaultbg].pixel |= (unsigned char)(0xff * alpha) << 24; ++ } ++ + return 0; + } + +@@ -1134,11 +1145,25 @@ xinit(int cols, int rows) + Window parent, root; + pid_t thispid = getpid(); + XColor xmousefg, xmousebg; ++ XWindowAttributes attr; ++ XVisualInfo vis; + + if (!(xw.dpy = XOpenDisplay(NULL))) + die("can't open display\n"); + xw.scr = XDefaultScreen(xw.dpy); +- xw.vis = XDefaultVisual(xw.dpy, xw.scr); ++ ++ root = XRootWindow(xw.dpy, xw.scr); ++ if (!(opt_embed && (parent = strtol(opt_embed, NULL, 0)))) ++ parent = root; ++ ++ if (XMatchVisualInfo(xw.dpy, xw.scr, 32, TrueColor, &vis) != 0) { ++ xw.vis = vis.visual; ++ xw.depth = vis.depth; ++ } else { ++ XGetWindowAttributes(xw.dpy, parent, &attr); ++ xw.vis = attr.visual; ++ xw.depth = attr.depth; ++ } + + /* font */ + if (!FcInit()) +@@ -1148,7 +1173,7 @@ xinit(int cols, int rows) + xloadfonts(usedfont, 0); + + /* colors */ +- xw.cmap = XDefaultColormap(xw.dpy, xw.scr); ++ xw.cmap = XCreateColormap(xw.dpy, parent, xw.vis, None); + xloadcols(); + + /* adjust fixed window geometry */ +@@ -1168,11 +1193,8 @@ xinit(int cols, int rows) + | ButtonMotionMask | ButtonPressMask | ButtonReleaseMask; + xw.attrs.colormap = xw.cmap; + +- root = XRootWindow(xw.dpy, xw.scr); +- if (!(opt_embed && (parent = strtol(opt_embed, NULL, 0)))) +- parent = root; +- xw.win = XCreateWindow(xw.dpy, root, xw.l, xw.t, +- win.w, win.h, 0, XDefaultDepth(xw.dpy, xw.scr), InputOutput, ++ xw.win = XCreateWindow(xw.dpy, parent, xw.l, xw.t, ++ win.w, win.h, 0, xw.depth, InputOutput, + xw.vis, CWBackPixel | CWBorderPixel | CWBitGravity + | CWEventMask | CWColormap, &xw.attrs); + if (parent != root) +@@ -1183,7 +1205,7 @@ xinit(int cols, int rows) + dc.gc = XCreateGC(xw.dpy, xw.win, GCGraphicsExposures, + &gcvalues); + xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h, +- DefaultDepth(xw.dpy, xw.scr)); ++ xw.depth); + XSetForeground(xw.dpy, dc.gc, dc.col[defaultbg].pixel); + XFillRectangle(xw.dpy, xw.buf, dc.gc, 0, 0, win.w, win.h); diff --git a/.config/suckless/st/patches/st-ligatures-alpha-scrollback-0.9.2.diff b/.config/suckless/st/patches/st-ligatures-alpha-scrollback-0.9.2.diff new file mode 100644 index 0000000..f1e428e --- /dev/null +++ b/.config/suckless/st/patches/st-ligatures-alpha-scrollback-0.9.2.diff @@ -0,0 +1,592 @@ +diff --git a/hb.c b/hb.c +new file mode 100644 +index 0000000..99412c8 +--- /dev/null ++++ b/hb.c +@@ -0,0 +1,125 @@ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "st.h" ++#include "hb.h" ++ ++#define FEATURE(c1,c2,c3,c4) { .tag = HB_TAG(c1,c2,c3,c4), .value = 1, .start = HB_FEATURE_GLOBAL_START, .end = HB_FEATURE_GLOBAL_END } ++#define BUFFER_STEP 256 ++ ++hb_font_t *hbfindfont(XftFont *match); ++ ++typedef struct { ++ XftFont *match; ++ hb_font_t *font; ++} HbFontMatch; ++ ++typedef struct { ++ size_t capacity; ++ HbFontMatch *fonts; ++} HbFontCache; ++ ++static HbFontCache hbfontcache = { 0, NULL }; ++ ++typedef struct { ++ size_t capacity; ++ Rune *runes; ++} RuneBuffer; ++ ++static RuneBuffer hbrunebuffer = { 0, NULL }; ++ ++/* ++ * Poplulate the array with a list of font features, wrapped in FEATURE macro, ++ * e. g. ++ * FEATURE('c', 'a', 'l', 't'), FEATURE('d', 'l', 'i', 'g') ++ */ ++hb_feature_t features[] = { }; ++ ++void ++hbunloadfonts() ++{ ++ for (int i = 0; i < hbfontcache.capacity; i++) { ++ hb_font_destroy(hbfontcache.fonts[i].font); ++ XftUnlockFace(hbfontcache.fonts[i].match); ++ } ++ ++ if (hbfontcache.fonts != NULL) { ++ free(hbfontcache.fonts); ++ hbfontcache.fonts = NULL; ++ } ++ hbfontcache.capacity = 0; ++} ++ ++hb_font_t * ++hbfindfont(XftFont *match) ++{ ++ for (int i = 0; i < hbfontcache.capacity; i++) { ++ if (hbfontcache.fonts[i].match == match) ++ return hbfontcache.fonts[i].font; ++ } ++ ++ /* Font not found in cache, caching it now. */ ++ hbfontcache.fonts = realloc(hbfontcache.fonts, sizeof(HbFontMatch) * (hbfontcache.capacity + 1)); ++ FT_Face face = XftLockFace(match); ++ hb_font_t *font = hb_ft_font_create(face, NULL); ++ if (font == NULL) ++ die("Failed to load Harfbuzz font."); ++ ++ hbfontcache.fonts[hbfontcache.capacity].match = match; ++ hbfontcache.fonts[hbfontcache.capacity].font = font; ++ hbfontcache.capacity += 1; ++ ++ return font; ++} ++ ++void hbtransform(HbTransformData *data, XftFont *xfont, const Glyph *glyphs, int start, int length) { ++ ushort mode = USHRT_MAX; ++ unsigned int glyph_count; ++ int rune_idx, glyph_idx, end = start + length; ++ ++ hb_font_t *font = hbfindfont(xfont); ++ if (font == NULL) ++ return; ++ ++ hb_buffer_t *buffer = hb_buffer_create(); ++ hb_buffer_set_direction(buffer, HB_DIRECTION_LTR); ++ hb_buffer_set_cluster_level(buffer, HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS); ++ ++ /* Resize the buffer if required length is larger. */ ++ if (hbrunebuffer.capacity < length) { ++ hbrunebuffer.capacity = (length / BUFFER_STEP + 1) * BUFFER_STEP; ++ hbrunebuffer.runes = realloc(hbrunebuffer.runes, hbrunebuffer.capacity * sizeof(Rune)); ++ } ++ ++ /* Fill buffer with codepoints. */ ++ for (rune_idx = 0, glyph_idx = start; glyph_idx < end; glyph_idx++, rune_idx++) { ++ hbrunebuffer.runes[rune_idx] = glyphs[glyph_idx].u; ++ mode = glyphs[glyph_idx].mode; ++ if (mode & ATTR_WDUMMY) ++ hbrunebuffer.runes[rune_idx] = 0x0020; ++ } ++ hb_buffer_add_codepoints(buffer, hbrunebuffer.runes, length, 0, length); ++ ++ /* Shape the segment. */ ++ hb_shape(font, buffer, features, sizeof(features)/sizeof(hb_feature_t)); ++ ++ /* Get new glyph info. */ ++ hb_glyph_info_t *info = hb_buffer_get_glyph_infos(buffer, &glyph_count); ++ hb_glyph_position_t *pos = hb_buffer_get_glyph_positions(buffer, &glyph_count); ++ ++ /* Fill the output. */ ++ data->buffer = buffer; ++ data->glyphs = info; ++ data->positions = pos; ++ data->count = glyph_count; ++} ++ ++void hbcleanup(HbTransformData *data) { ++ hb_buffer_destroy(data->buffer); ++ memset(data, 0, sizeof(HbTransformData)); ++} +diff --git a/hb.h b/hb.h +new file mode 100644 +index 0000000..3b0ef44 +--- /dev/null ++++ b/hb.h +@@ -0,0 +1,14 @@ ++#include ++#include ++#include ++ ++typedef struct { ++ hb_buffer_t *buffer; ++ hb_glyph_info_t *glyphs; ++ hb_glyph_position_t *positions; ++ unsigned int count; ++} HbTransformData; ++ ++void hbunloadfonts(); ++void hbtransform(HbTransformData *, XftFont *, const Glyph *, int, int); ++void hbcleanup(HbTransformData *); +diff --git a/st.c b/st.c +index 2478942..bba90d3 100644 +--- a/st.c ++++ b/st.c +@@ -2729,9 +2729,10 @@ draw(void) + + drawregion(0, 0, term.col, term.row); + if (term.scr == 0) + xdrawcursor(cx, term.c.y, term.line[term.c.y][cx], +- term.ocx, term.ocy, term.line[term.ocy][term.ocx]); ++ term.ocx, term.ocy, term.line[term.ocy][term.ocx], ++ term.line[term.ocy], term.col); + term.ocx = cx; + term.ocy = term.c.y; + xfinishdraw(); + if (ocx != term.ocx || ocy != term.ocy) +diff --git a/st.h b/st.h +index 78762a2..01eea49 100644 +--- a/st.h ++++ b/st.h +@@ -10,9 +10,10 @@ + #define BETWEEN(x, a, b) ((a) <= (x) && (x) <= (b)) + #define DIVCEIL(n, d) (((n) + ((d) - 1)) / (d)) + #define DEFAULT(a, b) (a) = (a) ? (a) : (b) + #define LIMIT(x, a, b) (x) = (x) < (a) ? (a) : (x) > (b) ? (b) : (x) +-#define ATTRCMP(a, b) ((a).mode != (b).mode || (a).fg != (b).fg || \ ++#define ATTRCMP(a, b) (((a).mode & (~ATTR_WRAP)) != ((b).mode & (~ATTR_WRAP)) || \ ++ (a).fg != (b).fg || \ + (a).bg != (b).bg) + #define TIMEDIFF(t1, t2) ((t1.tv_sec-t2.tv_sec)*1000 + \ + (t1.tv_nsec-t2.tv_nsec)/1E6) + #define MODBIT(x, set, bit) ((set) ? ((x) |= (bit)) : ((x) &= ~(bit))) +diff --git a/win.h b/win.h +index 6de960d..94679e4 100644 +--- a/win.h ++++ b/win.h +@@ -24,9 +24,9 @@ enum win_mode { + }; + + void xbell(void); + void xclipcopy(void); +-void xdrawcursor(int, int, Glyph, int, int, Glyph); ++void xdrawcursor(int, int, Glyph, int, int, Glyph, Line, int); + void xdrawline(Line, int, int, int); + void xfinishdraw(void); + void xloadcols(void); + int xsetcolorname(int, const char *); +diff --git a/x.c b/x.c +index 1e12ac8..b0819ac 100644 +--- a/x.c ++++ b/x.c +@@ -18,8 +18,9 @@ + char *argv0; + #include "arg.h" + #include "st.h" + #include "win.h" ++#include "hb.h" + + /* types used in config.h */ + typedef struct { + uint mod; +@@ -141,10 +142,11 @@ typedef struct { + GC gc; + } DC; + + static inline ushort sixd_to_16bit(int); ++static void xresetfontsettings(ushort mode, Font **font, int *frcflags); + static int xmakeglyphfontspecs(XftGlyphFontSpec *, const Glyph *, int, int, int); +-static void xdrawglyphfontspecs(const XftGlyphFontSpec *, Glyph, int, int, int); ++static void xdrawglyphfontspecs(const XftGlyphFontSpec *, Glyph, int, int, int, int); + static void xdrawglyph(Glyph, int, int); + static void xclear(int, int, int, int); + static int xgeommasktogravity(int); + static int ximopen(Display *); +@@ -758,9 +760,9 @@ xresize(int col, int row) + XftDrawChange(xw.draw, xw.buf); + xclear(0, 0, win.w, win.h); + + /* resize to new width */ +- xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec)); ++ xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec) * 4); + } + + ushort + sixd_to_16bit(int x) +@@ -1070,8 +1072,11 @@ xunloadfont(Font *f) + + void + xunloadfonts(void) + { ++ /* Clear Harfbuzz font cache. */ ++ hbunloadfonts(); ++ + /* Free the loaded fonts in the font cache. */ + while (frclen > 0) + XftFontClose(xw.dpy, frc[--frclen].font); + +@@ -1201,9 +1206,9 @@ xinit(int cols, int rows) + XSetForeground(xw.dpy, dc.gc, dc.col[defaultbg].pixel); + XFillRectangle(xw.dpy, xw.buf, dc.gc, 0, 0, win.w, win.h); + + /* font spec buffer */ +- xw.specbuf = xmalloc(cols * sizeof(GlyphFontSpec)); ++ xw.specbuf = xmalloc(cols * sizeof(GlyphFontSpec) * 4); + + /* Xft rendering context */ + xw.draw = XftDrawCreate(xw.dpy, xw.buf, xw.vis, xw.cmap); + +@@ -1255,144 +1260,155 @@ xinit(int cols, int rows) + if (xsel.xtarget == None) + xsel.xtarget = XA_STRING; + } + ++void ++xresetfontsettings(ushort mode, Font **font, int *frcflags) ++{ ++ *font = &dc.font; ++ if ((mode & ATTR_ITALIC) && (mode & ATTR_BOLD)) { ++ *font = &dc.ibfont; ++ *frcflags = FRC_ITALICBOLD; ++ } else if (mode & ATTR_ITALIC) { ++ *font = &dc.ifont; ++ *frcflags = FRC_ITALIC; ++ } else if (mode & ATTR_BOLD) { ++ *font = &dc.bfont; ++ *frcflags = FRC_BOLD; ++ } ++} ++ + int + xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x, int y) + { + float winx = borderpx + x * win.cw, winy = borderpx + y * win.ch, xp, yp; +- ushort mode, prevmode = USHRT_MAX; ++ ushort mode = glyphs[0].mode & ~ATTR_WRAP; + Font *font = &dc.font; + int frcflags = FRC_NORMAL; +- float runewidth = win.cw; ++ float runewidth = win.cw * ((glyphs[0].mode & ATTR_WIDE) ? 2.0f : 1.0f); + Rune rune; + FT_UInt glyphidx; + FcResult fcres; + FcPattern *fcpattern, *fontpattern; + FcFontSet *fcsets[] = { NULL }; + FcCharSet *fccharset; +- int i, f, numspecs = 0; ++ int f, code_idx, numspecs = 0; ++ float cluster_xp = xp, cluster_yp = yp; ++ HbTransformData shaped = { 0 }; + +- for (i = 0, xp = winx, yp = winy + font->ascent; i < len; ++i) { +- /* Fetch rune and mode for current glyph. */ +- rune = glyphs[i].u; +- mode = glyphs[i].mode; ++ /* Initial values. */ ++ xresetfontsettings(mode, &font, &frcflags); + +- /* Skip dummy wide-character spacing. */ +- if (mode == ATTR_WDUMMY) ++ /* Shape the segment. */ ++ hbtransform(&shaped, font->match, glyphs, 0, len); ++ xp = winx; yp = winy + font->ascent; ++ cluster_xp = xp; cluster_yp = yp; ++ ++ for (code_idx = 0; code_idx < shaped.count; code_idx++) { ++ int idx = shaped.glyphs[code_idx].cluster; ++ ++ if (glyphs[idx].mode & ATTR_WDUMMY) + continue; + +- /* Determine font for glyph if different from previous glyph. */ +- if (prevmode != mode) { +- prevmode = mode; +- font = &dc.font; +- frcflags = FRC_NORMAL; +- runewidth = win.cw * ((mode & ATTR_WIDE) ? 2.0f : 1.0f); +- if ((mode & ATTR_ITALIC) && (mode & ATTR_BOLD)) { +- font = &dc.ibfont; +- frcflags = FRC_ITALICBOLD; +- } else if (mode & ATTR_ITALIC) { +- font = &dc.ifont; +- frcflags = FRC_ITALIC; +- } else if (mode & ATTR_BOLD) { +- font = &dc.bfont; +- frcflags = FRC_BOLD; +- } +- yp = winy + font->ascent; ++ /* Advance the drawing cursor if we've moved to a new cluster */ ++ if (code_idx > 0 && idx != shaped.glyphs[code_idx - 1].cluster) { ++ xp += runewidth; ++ cluster_xp = xp; ++ cluster_yp = yp; + } + +- /* Lookup character index with default font. */ +- glyphidx = XftCharIndex(xw.dpy, font->match, rune); +- if (glyphidx) { ++ if (shaped.glyphs[code_idx].codepoint != 0) { ++ /* If symbol is found, put it into the specs. */ + specs[numspecs].font = font->match; +- specs[numspecs].glyph = glyphidx; +- specs[numspecs].x = (short)xp; +- specs[numspecs].y = (short)yp; +- xp += runewidth; ++ specs[numspecs].glyph = shaped.glyphs[code_idx].codepoint; ++ specs[numspecs].x = cluster_xp + (short)(shaped.positions[code_idx].x_offset / 64.); ++ specs[numspecs].y = cluster_yp - (short)(shaped.positions[code_idx].y_offset / 64.); ++ cluster_xp += shaped.positions[code_idx].x_advance / 64.; ++ cluster_yp += shaped.positions[code_idx].y_advance / 64.; + numspecs++; +- continue; +- } +- +- /* Fallback on font cache, search the font cache for match. */ +- for (f = 0; f < frclen; f++) { +- glyphidx = XftCharIndex(xw.dpy, frc[f].font, rune); +- /* Everything correct. */ +- if (glyphidx && frc[f].flags == frcflags) +- break; +- /* We got a default font for a not found glyph. */ +- if (!glyphidx && frc[f].flags == frcflags +- && frc[f].unicodep == rune) { +- break; ++ } else { ++ /* If it's not found, try to fetch it through the font cache. */ ++ rune = glyphs[idx].u; ++ for (f = 0; f < frclen; f++) { ++ glyphidx = XftCharIndex(xw.dpy, frc[f].font, rune); ++ /* Everything correct. */ ++ if (glyphidx && frc[f].flags == frcflags) ++ break; ++ /* We got a default font for a not found glyph. */ ++ if (!glyphidx && frc[f].flags == frcflags ++ && frc[f].unicodep == rune) { ++ break; ++ } + } +- } + +- /* Nothing was found. Use fontconfig to find matching font. */ +- if (f >= frclen) { +- if (!font->set) +- font->set = FcFontSort(0, font->pattern, +- 1, 0, &fcres); +- fcsets[0] = font->set; +- +- /* +- * Nothing was found in the cache. Now use +- * some dozen of Fontconfig calls to get the +- * font for one single character. +- * +- * Xft and fontconfig are design failures. +- */ +- fcpattern = FcPatternDuplicate(font->pattern); +- fccharset = FcCharSetCreate(); +- +- FcCharSetAddChar(fccharset, rune); +- FcPatternAddCharSet(fcpattern, FC_CHARSET, +- fccharset); +- FcPatternAddBool(fcpattern, FC_SCALABLE, 1); +- +- FcConfigSubstitute(0, fcpattern, +- FcMatchPattern); +- FcDefaultSubstitute(fcpattern); +- +- fontpattern = FcFontSetMatch(0, fcsets, 1, +- fcpattern, &fcres); +- +- /* Allocate memory for the new cache entry. */ +- if (frclen >= frccap) { +- frccap += 16; +- frc = xrealloc(frc, frccap * sizeof(Fontcache)); ++ /* Nothing was found. Use fontconfig to find matching font. */ ++ if (f >= frclen) { ++ if (!font->set) ++ font->set = FcFontSort(0, font->pattern, ++ 1, 0, &fcres); ++ fcsets[0] = font->set; ++ ++ /* ++ * Nothing was found in the cache. Now use ++ * some dozen of Fontconfig calls to get the ++ * font for one single character. ++ * ++ * Xft and fontconfig are design failures. ++ */ ++ fcpattern = FcPatternDuplicate(font->pattern); ++ fccharset = FcCharSetCreate(); ++ ++ FcCharSetAddChar(fccharset, rune); ++ FcPatternAddCharSet(fcpattern, FC_CHARSET, ++ fccharset); ++ FcPatternAddBool(fcpattern, FC_SCALABLE, 1); ++ ++ FcConfigSubstitute(0, fcpattern, ++ FcMatchPattern); ++ FcDefaultSubstitute(fcpattern); ++ ++ fontpattern = FcFontSetMatch(0, fcsets, 1, ++ fcpattern, &fcres); ++ ++ /* Allocate memory for the new cache entry. */ ++ if (frclen >= frccap) { ++ frccap += 16; ++ frc = xrealloc(frc, frccap * sizeof(Fontcache)); ++ } ++ ++ frc[frclen].font = XftFontOpenPattern(xw.dpy, ++ fontpattern); ++ if (!frc[frclen].font) ++ die("XftFontOpenPattern failed seeking fallback font: %s\n", ++ strerror(errno)); ++ frc[frclen].flags = frcflags; ++ frc[frclen].unicodep = rune; ++ ++ glyphidx = XftCharIndex(xw.dpy, frc[frclen].font, rune); ++ ++ f = frclen; ++ frclen++; ++ ++ FcPatternDestroy(fcpattern); ++ FcCharSetDestroy(fccharset); + } + +- frc[frclen].font = XftFontOpenPattern(xw.dpy, +- fontpattern); +- if (!frc[frclen].font) +- die("XftFontOpenPattern failed seeking fallback font: %s\n", +- strerror(errno)); +- frc[frclen].flags = frcflags; +- frc[frclen].unicodep = rune; +- +- glyphidx = XftCharIndex(xw.dpy, frc[frclen].font, rune); +- +- f = frclen; +- frclen++; +- +- FcPatternDestroy(fcpattern); +- FcCharSetDestroy(fccharset); ++ specs[numspecs].font = frc[f].font; ++ specs[numspecs].glyph = glyphidx; ++ specs[numspecs].x = (short)xp; ++ specs[numspecs].y = (short)yp; ++ numspecs++; + } +- +- specs[numspecs].font = frc[f].font; +- specs[numspecs].glyph = glyphidx; +- specs[numspecs].x = (short)xp; +- specs[numspecs].y = (short)yp; +- xp += runewidth; +- numspecs++; + } + ++ /* Cleanup and get ready for next segment. */ ++ hbcleanup(&shaped); + return numspecs; + } + + void +-xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, int y) ++xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, int y, int charlen) + { +- int charlen = len * ((base.mode & ATTR_WIDE) ? 2 : 1); + int winx = borderpx + x * win.cw, winy = borderpx + y * win.ch, + width = charlen * win.cw; + Color *fg, *bg, *temp, revfg, revbg, truefg, truebg; + XRenderColor colfg, colbg; +@@ -1526,23 +1542,26 @@ xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, i + void + xdrawglyph(Glyph g, int x, int y) + { + int numspecs; +- XftGlyphFontSpec spec; ++ XftGlyphFontSpec *specs = xw.specbuf; + +- numspecs = xmakeglyphfontspecs(&spec, &g, 1, x, y); +- xdrawglyphfontspecs(&spec, g, numspecs, x, y); ++ numspecs = xmakeglyphfontspecs(specs, &g, 1, x, y); ++ xdrawglyphfontspecs(specs, g, numspecs, x, y, (g.mode & ATTR_WIDE) ? 2 : 1); + } + + void +-xdrawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og) ++xdrawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og, Line line, int len) + { + Color drawcol; + + /* remove the old cursor */ + if (selected(ox, oy)) + og.mode ^= ATTR_REVERSE; +- xdrawglyph(og, ox, oy); ++ ++ /* Redraw the line where cursor was previously. ++ * It will restore the ligatures broken by the cursor. */ ++ xdrawline(line, 0, oy, len); + + if (IS_SET(MODE_HIDE)) + return; + +@@ -1674,30 +1693,30 @@ xdrawline(Line line, int x1, int y1, int x2) + int i, x, ox, numspecs; + Glyph base, new; + XftGlyphFontSpec *specs = xw.specbuf; + +- numspecs = xmakeglyphfontspecs(specs, &line[x1], x2 - x1, x1, y1); + i = ox = 0; +- for (x = x1; x < x2 && i < numspecs; x++) { ++ for (x = x1; x < x2; x++) { + new = line[x]; + if (new.mode == ATTR_WDUMMY) + continue; + if (selected(x, y1)) + new.mode ^= ATTR_REVERSE; +- if (i > 0 && ATTRCMP(base, new)) { +- xdrawglyphfontspecs(specs, base, i, ox, y1); +- specs += i; +- numspecs -= i; ++ if ((i > 0) && ATTRCMP(base, new)) { ++ numspecs = xmakeglyphfontspecs(specs, &line[ox], x - ox, ox, y1); ++ xdrawglyphfontspecs(specs, base, numspecs, ox, y1, x - ox); + i = 0; + } + if (i == 0) { + ox = x; + base = new; + } + i++; + } +- if (i > 0) +- xdrawglyphfontspecs(specs, base, i, ox, y1); ++ if (i > 0) { ++ numspecs = xmakeglyphfontspecs(specs, &line[ox], x2 - ox, ox, y1); ++ xdrawglyphfontspecs(specs, base, numspecs, ox, y1, x2 - ox); ++ } + } + + void + xfinishdraw(void) + + diff --git a/.config/suckless/st/st.c b/.config/suckless/st/st.c index 0ef7929..8ddde30 100644 --- a/.config/suckless/st/st.c +++ b/.config/suckless/st/st.c @@ -2727,7 +2727,8 @@ draw(void) drawregion(0, 0, term.col, term.row); if (term.scr == 0) xdrawcursor(cx, term.c.y, term.line[term.c.y][cx], - term.ocx, term.ocy, term.line[term.ocy][term.ocx]); + term.ocx, term.ocy, term.line[term.ocy][term.ocx], + term.line[term.ocy], term.col); term.ocx = cx; term.ocy = term.c.y; xfinishdraw(); diff --git a/.config/suckless/st/st.h b/.config/suckless/st/st.h index 818a6f8..4e584b6 100644 --- a/.config/suckless/st/st.h +++ b/.config/suckless/st/st.h @@ -11,7 +11,8 @@ #define DIVCEIL(n, d) (((n) + ((d) - 1)) / (d)) #define DEFAULT(a, b) (a) = (a) ? (a) : (b) #define LIMIT(x, a, b) (x) = (x) < (a) ? (a) : (x) > (b) ? (b) : (x) -#define ATTRCMP(a, b) ((a).mode != (b).mode || (a).fg != (b).fg || \ +#define ATTRCMP(a, b) (((a).mode & (~ATTR_WRAP)) != ((b).mode & (~ATTR_WRAP)) || \ + (a).fg != (b).fg || \ (a).bg != (b).bg) #define TIMEDIFF(t1, t2) ((t1.tv_sec-t2.tv_sec)*1000 + \ (t1.tv_nsec-t2.tv_nsec)/1E6) diff --git a/.config/suckless/st/win.h b/.config/suckless/st/win.h index 0081092..2c03185 100644 --- a/.config/suckless/st/win.h +++ b/.config/suckless/st/win.h @@ -23,7 +23,7 @@ enum win_mode { void xbell(void); void xclipcopy(void); -void xdrawcursor(int, int, Glyph, int, int, Glyph); +void xdrawcursor(int, int, Glyph, int, int, Glyph, Line, int); void xdrawline(Line, int, int, int); void xfinishdraw(void); void xloadcols(void); diff --git a/.config/suckless/st/x.c b/.config/suckless/st/x.c index 5fd37ea..ca1d0bc 100644 --- a/.config/suckless/st/x.c +++ b/.config/suckless/st/x.c @@ -19,6 +19,7 @@ char *argv0; #include "arg.h" #include "st.h" #include "win.h" +#include "hb.h" /* types used in config.h */ typedef struct { @@ -106,6 +107,7 @@ typedef struct { XSetWindowAttributes attrs; int scr; int isfixed; /* is fixed geometry? */ + int depth; /* bit depth */ int l, t; /* left and top offset */ int gm; /* geometry mask */ } XWindow; @@ -142,8 +144,9 @@ typedef struct { } DC; static inline ushort sixd_to_16bit(int); +static void xresetfontsettings(ushort mode, Font **font, int *frcflags); static int xmakeglyphfontspecs(XftGlyphFontSpec *, const Glyph *, int, int, int); -static void xdrawglyphfontspecs(const XftGlyphFontSpec *, Glyph, int, int, int); +static void xdrawglyphfontspecs(const XftGlyphFontSpec *, Glyph, int, int, int, int); static void xdrawglyph(Glyph, int, int); static void xclear(int, int, int, int); static int xgeommasktogravity(int); @@ -756,12 +759,12 @@ xresize(int col, int row) XFreePixmap(xw.dpy, xw.buf); xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h, - DefaultDepth(xw.dpy, xw.scr)); + xw.depth); XftDrawChange(xw.draw, xw.buf); xclear(0, 0, win.w, win.h); /* resize to new width */ - xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec)); + xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec) * 4); } ushort @@ -816,6 +819,10 @@ xloadcols(void) else die("could not allocate color %d\n", i); } + + dc.col[defaultbg].color.alpha = (unsigned short)(0xffff * alpha); + dc.col[defaultbg].pixel &= 0x00FFFFFF; + dc.col[defaultbg].pixel |= (unsigned char)(0xff * alpha) << 24; loaded = 1; } @@ -846,6 +853,12 @@ xsetcolorname(int x, const char *name) XftColorFree(xw.dpy, xw.vis, xw.cmap, &dc.col[x]); dc.col[x] = ncolor; + if (x == defaultbg) { + dc.col[defaultbg].color.alpha = (unsigned short)(0xffff * alpha); + dc.col[defaultbg].pixel &= 0x00FFFFFF; + dc.col[defaultbg].pixel |= (unsigned char)(0xff * alpha) << 24; + } + return 0; } @@ -1066,6 +1079,9 @@ xunloadfont(Font *f) void xunloadfonts(void) { + /* Clear Harfbuzz font cache. */ + hbunloadfonts(); + /* Free the loaded fonts in the font cache. */ while (frclen > 0) XftFontClose(xw.dpy, frc[--frclen].font); @@ -1138,11 +1154,25 @@ xinit(int cols, int rows) Window parent, root; pid_t thispid = getpid(); XColor xmousefg, xmousebg; + XWindowAttributes attr; + XVisualInfo vis; if (!(xw.dpy = XOpenDisplay(NULL))) die("can't open display\n"); xw.scr = XDefaultScreen(xw.dpy); - xw.vis = XDefaultVisual(xw.dpy, xw.scr); + + root = XRootWindow(xw.dpy, xw.scr); + if (!(opt_embed && (parent = strtol(opt_embed, NULL, 0)))) + parent = root; + + if (XMatchVisualInfo(xw.dpy, xw.scr, 32, TrueColor, &vis) != 0) { + xw.vis = vis.visual; + xw.depth = vis.depth; + } else { + XGetWindowAttributes(xw.dpy, parent, &attr); + xw.vis = attr.visual; + xw.depth = attr.depth; + } /* font */ if (!FcInit()) @@ -1152,7 +1182,7 @@ xinit(int cols, int rows) xloadfonts(usedfont, 0); /* colors */ - xw.cmap = XDefaultColormap(xw.dpy, xw.scr); + xw.cmap = XCreateColormap(xw.dpy, parent, xw.vis, None); xloadcols(); /* adjust fixed window geometry */ @@ -1172,11 +1202,8 @@ xinit(int cols, int rows) | ButtonMotionMask | ButtonPressMask | ButtonReleaseMask; xw.attrs.colormap = xw.cmap; - root = XRootWindow(xw.dpy, xw.scr); - if (!(opt_embed && (parent = strtol(opt_embed, NULL, 0)))) - parent = root; - xw.win = XCreateWindow(xw.dpy, root, xw.l, xw.t, - win.w, win.h, 0, XDefaultDepth(xw.dpy, xw.scr), InputOutput, + xw.win = XCreateWindow(xw.dpy, parent, xw.l, xw.t, + win.w, win.h, 0, xw.depth, InputOutput, xw.vis, CWBackPixel | CWBorderPixel | CWBitGravity | CWEventMask | CWColormap, &xw.attrs); if (parent != root) @@ -1187,12 +1214,12 @@ xinit(int cols, int rows) dc.gc = XCreateGC(xw.dpy, xw.win, GCGraphicsExposures, &gcvalues); xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h, - DefaultDepth(xw.dpy, xw.scr)); + xw.depth); XSetForeground(xw.dpy, dc.gc, dc.col[defaultbg].pixel); XFillRectangle(xw.dpy, xw.buf, dc.gc, 0, 0, win.w, win.h); /* font spec buffer */ - xw.specbuf = xmalloc(cols * sizeof(GlyphFontSpec)); + xw.specbuf = xmalloc(cols * sizeof(GlyphFontSpec) * 4); /* Xft rendering context */ xw.draw = XftDrawCreate(xw.dpy, xw.buf, xw.vis, xw.cmap); @@ -1246,142 +1273,153 @@ xinit(int cols, int rows) xsel.xtarget = XA_STRING; } -int -xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x, int y) +void +xresetfontsettings(ushort mode, Font **font, int *frcflags) { - float winx = win.hborderpx + x * win.cw, winy = win.vborderpx + y * win.ch, xp, yp; - ushort mode, prevmode = USHRT_MAX; - Font *font = &dc.font; - int frcflags = FRC_NORMAL; - float runewidth = win.cw; - Rune rune; - FT_UInt glyphidx; - FcResult fcres; - FcPattern *fcpattern, *fontpattern; - FcFontSet *fcsets[] = { NULL }; - FcCharSet *fccharset; - int i, f, numspecs = 0; + *font = &dc.font; + if ((mode & ATTR_ITALIC) && (mode & ATTR_BOLD)) { + *font = &dc.ibfont; + *frcflags = FRC_ITALICBOLD; + } else if (mode & ATTR_ITALIC) { + *font = &dc.ifont; + *frcflags = FRC_ITALIC; + } else if (mode & ATTR_BOLD) { + *font = &dc.bfont; + *frcflags = FRC_BOLD; + } +} - for (i = 0, xp = winx, yp = winy + font->ascent; i < len; ++i) { - /* Fetch rune and mode for current glyph. */ - rune = glyphs[i].u; - mode = glyphs[i].mode; + int + xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x, int y) + { + float winx = borderpx + x * win.cw, winy = borderpx + y * win.ch, xp, yp; + ushort mode = glyphs[0].mode & ~ATTR_WRAP; + Font *font = &dc.font; + int frcflags = FRC_NORMAL; + float runewidth = win.cw * ((glyphs[0].mode & ATTR_WIDE) ? 2.0f : 1.0f); + Rune rune; + FT_UInt glyphidx; + FcResult fcres; + FcPattern *fcpattern, *fontpattern; + FcFontSet *fcsets[] = { NULL }; + FcCharSet *fccharset; + int f, code_idx, numspecs = 0; + float cluster_xp = xp, cluster_yp = yp; + HbTransformData shaped = { 0 }; + + /* Initial values. */ + xresetfontsettings(mode, &font, &frcflags); + + /* Shape the segment. */ + hbtransform(&shaped, font->match, glyphs, 0, len); + xp = winx; yp = winy + font->ascent; + cluster_xp = xp; cluster_yp = yp; - /* Skip dummy wide-character spacing. */ - if (mode == ATTR_WDUMMY) - continue; + for (code_idx = 0; code_idx < shaped.count; code_idx++) { + int idx = shaped.glyphs[code_idx].cluster; - /* Determine font for glyph if different from previous glyph. */ - if (prevmode != mode) { - prevmode = mode; - font = &dc.font; - frcflags = FRC_NORMAL; - runewidth = win.cw * ((mode & ATTR_WIDE) ? 2.0f : 1.0f); - if ((mode & ATTR_ITALIC) && (mode & ATTR_BOLD)) { - font = &dc.ibfont; - frcflags = FRC_ITALICBOLD; - } else if (mode & ATTR_ITALIC) { - font = &dc.ifont; - frcflags = FRC_ITALIC; - } else if (mode & ATTR_BOLD) { - font = &dc.bfont; - frcflags = FRC_BOLD; - } - yp = winy + font->ascent; - } + if (glyphs[idx].mode & ATTR_WDUMMY) + continue; + + /* Advance the drawing cursor if we've moved to a new cluster */ + if (code_idx > 0 && idx != shaped.glyphs[code_idx - 1].cluster) { + xp += runewidth; + cluster_xp = xp; + cluster_yp = yp; + } + + if (shaped.glyphs[code_idx].codepoint != 0) { + /* If symbol is found, put it into the specs. */ + specs[numspecs].font = font->match; + specs[numspecs].glyph = shaped.glyphs[code_idx].codepoint; + specs[numspecs].x = cluster_xp + (short)(shaped.positions[code_idx].x_offset / 64.); + specs[numspecs].y = cluster_yp - (short)(shaped.positions[code_idx].y_offset / 64.); + cluster_xp += shaped.positions[code_idx].x_advance / 64.; + cluster_yp += shaped.positions[code_idx].y_advance / 64.; + numspecs++; + } else { + /* If it's not found, try to fetch it through the font cache. */ + rune = glyphs[idx].u; + for (f = 0; f < frclen; f++) { + glyphidx = XftCharIndex(xw.dpy, frc[f].font, rune); + /* Everything correct. */ + if (glyphidx && frc[f].flags == frcflags) + break; + /* We got a default font for a not found glyph. */ + if (!glyphidx && frc[f].flags == frcflags + && frc[f].unicodep == rune) { + break; + } + } + + /* Nothing was found. Use fontconfig to find matching font. */ + if (f >= frclen) { + if (!font->set) + font->set = FcFontSort(0, font->pattern, + 1, 0, &fcres); + fcsets[0] = font->set; - /* Lookup character index with default font. */ - glyphidx = XftCharIndex(xw.dpy, font->match, rune); - if (glyphidx) { - specs[numspecs].font = font->match; + /* + * Nothing was found in the cache. Now use + * some dozen of Fontconfig calls to get the + * font for one single character. + * + * Xft and fontconfig are design failures. + */ + fcpattern = FcPatternDuplicate(font->pattern); + fccharset = FcCharSetCreate(); + + FcCharSetAddChar(fccharset, rune); + FcPatternAddCharSet(fcpattern, FC_CHARSET, + fccharset); + FcPatternAddBool(fcpattern, FC_SCALABLE, 1); + + FcConfigSubstitute(0, fcpattern, + FcMatchPattern); + FcDefaultSubstitute(fcpattern); + + fontpattern = FcFontSetMatch(0, fcsets, 1, + fcpattern, &fcres); + + /* Allocate memory for the new cache entry. */ + if (frclen >= frccap) { + frccap += 16; + frc = xrealloc(frc, frccap * sizeof(Fontcache)); + } + + frc[frclen].font = XftFontOpenPattern(xw.dpy, + fontpattern); + if (!frc[frclen].font) + die("XftFontOpenPattern failed seeking fallback font: %s\n", + strerror(errno)); + frc[frclen].flags = frcflags; + frc[frclen].unicodep = rune; + + glyphidx = XftCharIndex(xw.dpy, frc[frclen].font, rune); + + f = frclen; + frclen++; + + FcPatternDestroy(fcpattern); + FcCharSetDestroy(fccharset); + } + + specs[numspecs].font = frc[f].font; specs[numspecs].glyph = glyphidx; specs[numspecs].x = (short)xp; specs[numspecs].y = (short)yp; - xp += runewidth; numspecs++; - continue; - } - - /* Fallback on font cache, search the font cache for match. */ - for (f = 0; f < frclen; f++) { - glyphidx = XftCharIndex(xw.dpy, frc[f].font, rune); - /* Everything correct. */ - if (glyphidx && frc[f].flags == frcflags) - break; - /* We got a default font for a not found glyph. */ - if (!glyphidx && frc[f].flags == frcflags - && frc[f].unicodep == rune) { - break; - } - } - - /* Nothing was found. Use fontconfig to find matching font. */ - if (f >= frclen) { - if (!font->set) - font->set = FcFontSort(0, font->pattern, - 1, 0, &fcres); - fcsets[0] = font->set; - - /* - * Nothing was found in the cache. Now use - * some dozen of Fontconfig calls to get the - * font for one single character. - * - * Xft and fontconfig are design failures. - */ - fcpattern = FcPatternDuplicate(font->pattern); - fccharset = FcCharSetCreate(); - - FcCharSetAddChar(fccharset, rune); - FcPatternAddCharSet(fcpattern, FC_CHARSET, - fccharset); - FcPatternAddBool(fcpattern, FC_SCALABLE, 1); - - FcConfigSubstitute(0, fcpattern, - FcMatchPattern); - FcDefaultSubstitute(fcpattern); - - fontpattern = FcFontSetMatch(0, fcsets, 1, - fcpattern, &fcres); - - /* Allocate memory for the new cache entry. */ - if (frclen >= frccap) { - frccap += 16; - frc = xrealloc(frc, frccap * sizeof(Fontcache)); - } - - frc[frclen].font = XftFontOpenPattern(xw.dpy, - fontpattern); - if (!frc[frclen].font) - die("XftFontOpenPattern failed seeking fallback font: %s\n", - strerror(errno)); - frc[frclen].flags = frcflags; - frc[frclen].unicodep = rune; - - glyphidx = XftCharIndex(xw.dpy, frc[frclen].font, rune); - - f = frclen; - frclen++; - - FcPatternDestroy(fcpattern); - FcCharSetDestroy(fccharset); - } - - specs[numspecs].font = frc[f].font; - specs[numspecs].glyph = glyphidx; - specs[numspecs].x = (short)xp; - specs[numspecs].y = (short)yp; - xp += runewidth; - numspecs++; - } - - return numspecs; -} + } + } + + /* Cleanup and get ready for next segment. */ + hbcleanup(&shaped); + return numspecs; + } void -xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, int y) +xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, int y, int charlen) { - int charlen = len * ((base.mode & ATTR_WIDE) ? 2 : 1); int winx = win.hborderpx + x * win.cw, winy = win.vborderpx + y * win.ch, width = charlen * win.cw; Color *fg, *bg, *temp, revfg, revbg, truefg, truebg; @@ -1518,21 +1556,24 @@ void xdrawglyph(Glyph g, int x, int y) { int numspecs; - XftGlyphFontSpec spec; + XftGlyphFontSpec *specs = xw.specbuf; - numspecs = xmakeglyphfontspecs(&spec, &g, 1, x, y); - xdrawglyphfontspecs(&spec, g, numspecs, x, y); + numspecs = xmakeglyphfontspecs(specs, &g, 1, x, y); + xdrawglyphfontspecs(specs, g, numspecs, x, y, (g.mode & ATTR_WIDE) ? 2 : 1); } void -xdrawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og) +xdrawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og, Line line, int len) { Color drawcol; /* remove the old cursor */ if (selected(ox, oy)) og.mode ^= ATTR_REVERSE; - xdrawglyph(og, ox, oy); + + /* Redraw the line where cursor was previously. + * It will restore the ligatures broken by the cursor. */ + xdrawline(line, 0, oy, len); if (IS_SET(MODE_HIDE)) return; @@ -1642,18 +1683,16 @@ xdrawline(Line line, int x1, int y1, int x2) Glyph base, new; XftGlyphFontSpec *specs = xw.specbuf; - numspecs = xmakeglyphfontspecs(specs, &line[x1], x2 - x1, x1, y1); i = ox = 0; - for (x = x1; x < x2 && i < numspecs; x++) { + for (x = x1; x < x2; x++) { new = line[x]; if (new.mode == ATTR_WDUMMY) continue; if (selected(x, y1)) new.mode ^= ATTR_REVERSE; - if (i > 0 && ATTRCMP(base, new)) { - xdrawglyphfontspecs(specs, base, i, ox, y1); - specs += i; - numspecs -= i; + if ((i > 0) && ATTRCMP(base, new)) { + numspecs = xmakeglyphfontspecs(specs, &line[ox], x - ox, ox, y1); + xdrawglyphfontspecs(specs, base, numspecs, ox, y1, x - ox); i = 0; } if (i == 0) { @@ -1662,8 +1701,10 @@ xdrawline(Line line, int x1, int y1, int x2) } i++; } - if (i > 0) - xdrawglyphfontspecs(specs, base, i, ox, y1); + if (i > 0) { + numspecs = xmakeglyphfontspecs(specs, &line[ox], x2 - ox, ox, y1); + xdrawglyphfontspecs(specs, base, numspecs, ox, y1, x2 - ox); + } } void