drw.c (11455B)
1 /* See LICENSE file for copyright and license details. */ 2 #include <stdio.h> 3 #include <stdlib.h> 4 #include <string.h> 5 #include <X11/Xlib.h> 6 #include <X11/Xft/Xft.h> 7 8 #include "drw.h" 9 #include "util.h" 10 11 #define UTF_INVALID 0xFFFD 12 #define UTF_SIZ 4 13 14 static const unsigned char utfbyte[UTF_SIZ + 1] = {0x80, 0, 0xC0, 0xE0, 0xF0}; 15 static const unsigned char utfmask[UTF_SIZ + 1] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8}; 16 static const long utfmin[UTF_SIZ + 1] = { 0, 0, 0x80, 0x800, 0x10000}; 17 static const long utfmax[UTF_SIZ + 1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF}; 18 19 static long 20 utf8decodebyte(const char c, size_t *i) 21 { 22 for (*i = 0; *i < (UTF_SIZ + 1); ++(*i)) 23 if (((unsigned char)c & utfmask[*i]) == utfbyte[*i]) 24 return (unsigned char)c & ~utfmask[*i]; 25 return 0; 26 } 27 28 static size_t 29 utf8validate(long *u, size_t i) 30 { 31 if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF)) 32 *u = UTF_INVALID; 33 for (i = 1; *u > utfmax[i]; ++i) 34 ; 35 return i; 36 } 37 38 static size_t 39 utf8decode(const char *c, long *u, size_t clen) 40 { 41 size_t i, j, len, type; 42 long udecoded; 43 44 *u = UTF_INVALID; 45 if (!clen) 46 return 0; 47 udecoded = utf8decodebyte(c[0], &len); 48 if (!BETWEEN(len, 1, UTF_SIZ)) 49 return 1; 50 for (i = 1, j = 1; i < clen && j < len; ++i, ++j) { 51 udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type); 52 if (type) 53 return j; 54 } 55 if (j < len) 56 return 0; 57 *u = udecoded; 58 utf8validate(u, len); 59 60 return len; 61 } 62 63 Drw * 64 drw_create(Display *dpy, int screen, Window root, unsigned int w, unsigned int h) 65 { 66 Drw *drw = ecalloc(1, sizeof(Drw)); 67 68 drw->dpy = dpy; 69 drw->screen = screen; 70 drw->root = root; 71 drw->w = w; 72 drw->h = h; 73 drw->drawable = XCreatePixmap(dpy, root, w, h, DefaultDepth(dpy, screen)); 74 drw->gc = XCreateGC(dpy, root, 0, NULL); 75 XSetLineAttributes(dpy, drw->gc, 1, LineSolid, CapButt, JoinMiter); 76 77 return drw; 78 } 79 80 void 81 drw_resize(Drw *drw, unsigned int w, unsigned int h) 82 { 83 if (!drw) 84 return; 85 86 drw->w = w; 87 drw->h = h; 88 if (drw->drawable) 89 XFreePixmap(drw->dpy, drw->drawable); 90 drw->drawable = XCreatePixmap(drw->dpy, drw->root, w, h, DefaultDepth(drw->dpy, drw->screen)); 91 } 92 93 void 94 drw_free(Drw *drw) 95 { 96 XFreePixmap(drw->dpy, drw->drawable); 97 XFreeGC(drw->dpy, drw->gc); 98 drw_fontset_free(drw->fonts); 99 free(drw); 100 } 101 102 /* This function is an implementation detail. Library users should use 103 * drw_fontset_create instead. 104 */ 105 static Fnt * 106 xfont_create(Drw *drw, const char *fontname, FcPattern *fontpattern) 107 { 108 Fnt *font; 109 XftFont *xfont = NULL; 110 FcPattern *pattern = NULL; 111 112 if (fontname) { 113 /* Using the pattern found at font->xfont->pattern does not yield the 114 * same substitution results as using the pattern returned by 115 * FcNameParse; using the latter results in the desired fallback 116 * behaviour whereas the former just results in missing-character 117 * rectangles being drawn, at least with some fonts. */ 118 if (!(xfont = XftFontOpenName(drw->dpy, drw->screen, fontname))) { 119 fprintf(stderr, "error, cannot load font from name: '%s'\n", fontname); 120 return NULL; 121 } 122 if (!(pattern = FcNameParse((FcChar8 *) fontname))) { 123 fprintf(stderr, "error, cannot parse font name to pattern: '%s'\n", fontname); 124 XftFontClose(drw->dpy, xfont); 125 return NULL; 126 } 127 } else if (fontpattern) { 128 if (!(xfont = XftFontOpenPattern(drw->dpy, fontpattern))) { 129 fprintf(stderr, "error, cannot load font from pattern.\n"); 130 return NULL; 131 } 132 } else { 133 die("no font specified."); 134 } 135 136 /* Do not allow using color fonts. This is a workaround for a BadLength 137 * error from Xft with color glyphs. Modelled on the Xterm workaround. See 138 * https://bugzilla.redhat.com/show_bug.cgi?id=1498269 139 * https://lists.suckless.org/dev/1701/30932.html 140 * https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=916349 141 * and lots more all over the internet. 142 */ 143 // FcBool iscol; 144 // if(FcPatternGetBool(xfont->pattern, FC_COLOR, 0, &iscol) == FcResultMatch && iscol) { 145 // XftFontClose(drw->dpy, xfont); 146 // return NULL; 147 // } 148 149 font = ecalloc(1, sizeof(Fnt)); 150 font->xfont = xfont; 151 font->pattern = pattern; 152 font->h = xfont->ascent + xfont->descent; 153 font->dpy = drw->dpy; 154 155 return font; 156 } 157 158 static void 159 xfont_free(Fnt *font) 160 { 161 if (!font) 162 return; 163 if (font->pattern) 164 FcPatternDestroy(font->pattern); 165 XftFontClose(font->dpy, font->xfont); 166 free(font); 167 } 168 169 Fnt* 170 drw_fontset_create(Drw* drw, const char *fonts[], size_t fontcount) 171 { 172 Fnt *cur, *ret = NULL; 173 size_t i; 174 175 if (!drw || !fonts) 176 return NULL; 177 178 for (i = 1; i <= fontcount; i++) { 179 if ((cur = xfont_create(drw, fonts[fontcount - i], NULL))) { 180 cur->next = ret; 181 ret = cur; 182 } 183 } 184 return (drw->fonts = ret); 185 } 186 187 void 188 drw_fontset_free(Fnt *font) 189 { 190 if (font) { 191 drw_fontset_free(font->next); 192 xfont_free(font); 193 } 194 } 195 196 void 197 drw_clr_create(Drw *drw, Clr *dest, const char *clrname) 198 { 199 if (!drw || !dest || !clrname) 200 return; 201 202 if (!XftColorAllocName(drw->dpy, DefaultVisual(drw->dpy, drw->screen), 203 DefaultColormap(drw->dpy, drw->screen), 204 clrname, dest)) 205 die("error, cannot allocate color '%s'", clrname); 206 } 207 208 /* Wrapper to create color schemes. The caller has to call free(3) on the 209 * returned color scheme when done using it. */ 210 Clr * 211 drw_scm_create(Drw *drw, char *clrnames[], size_t clrcount) 212 { 213 size_t i; 214 Clr *ret; 215 216 /* need at least two colors for a scheme */ 217 if (!drw || !clrnames || clrcount < 2 || !(ret = ecalloc(clrcount, sizeof(XftColor)))) 218 return NULL; 219 220 for (i = 0; i < clrcount; i++) 221 drw_clr_create(drw, &ret[i], clrnames[i]); 222 return ret; 223 } 224 225 void 226 drw_setfontset(Drw *drw, Fnt *set) 227 { 228 if (drw) 229 drw->fonts = set; 230 } 231 232 void 233 drw_setscheme(Drw *drw, Clr *scm) 234 { 235 if (drw) 236 drw->scheme = scm; 237 } 238 239 void 240 drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int invert) 241 { 242 if (!drw || !drw->scheme) 243 return; 244 XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme[ColBg].pixel : drw->scheme[ColFg].pixel); 245 if (filled) 246 XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h); 247 else 248 XDrawRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w - 1, h - 1); 249 } 250 251 void 252 drw_polygon(Drw *drw, int x, int y, int ow, int oh, int sw, int sh, const XPoint *points, int npoints, int shape, int filled) /* wrapper function to scale and draw a polygon with X11 */ 253 { 254 if (!drw || !drw->scheme) 255 return; 256 XSetForeground(drw->dpy, drw->gc, drw->scheme[ColFg].pixel); 257 if (!filled) { /* reduces the scaled width and height by 1 when drawing the outline to compensate for X11 drawing the line 1 pixel over */ 258 sw -= 1; 259 sh -= 1; 260 } 261 XPoint scaledpoints[npoints]; 262 memcpy(scaledpoints, points, npoints); 263 for (int v = 0; v < npoints; v++) 264 scaledpoints[v] = (XPoint){ .x = points[v].x * sw / ow + x, .y = points[v].y * sh / oh + y }; 265 if (filled) 266 XFillPolygon(drw->dpy, drw->drawable, drw->gc, scaledpoints, npoints, shape, CoordModeOrigin); /* Change shape to 'Convex' or 'Complex' in dwm.c if the shape is not 'Nonconvex' */ 267 else 268 XDrawLines(drw->dpy, drw->drawable, drw->gc, scaledpoints, npoints, CoordModeOrigin); 269 } 270 271 int 272 drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, unsigned int lpad, const char *text, int invert) 273 { 274 char buf[1024]; 275 int ty; 276 unsigned int ew; 277 XftDraw *d = NULL; 278 Fnt *usedfont, *curfont, *nextfont; 279 size_t i, len; 280 int utf8strlen, utf8charlen, render = x || y || w || h; 281 long utf8codepoint = 0; 282 const char *utf8str; 283 FcCharSet *fccharset; 284 FcPattern *fcpattern; 285 FcPattern *match; 286 XftResult result; 287 int charexists = 0; 288 289 if (!drw || (render && !drw->scheme) || !text || !drw->fonts) 290 return 0; 291 292 if (!render) { 293 w = ~w; 294 } else { 295 XSetForeground(drw->dpy, drw->gc, drw->scheme[invert ? ColFg : ColBg].pixel); 296 XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h); 297 d = XftDrawCreate(drw->dpy, drw->drawable, 298 DefaultVisual(drw->dpy, drw->screen), 299 DefaultColormap(drw->dpy, drw->screen)); 300 x += lpad; 301 w -= lpad; 302 } 303 304 usedfont = drw->fonts; 305 while (1) { 306 utf8strlen = 0; 307 utf8str = text; 308 nextfont = NULL; 309 while (*text) { 310 utf8charlen = utf8decode(text, &utf8codepoint, UTF_SIZ); 311 for (curfont = drw->fonts; curfont; curfont = curfont->next) { 312 charexists = charexists || XftCharExists(drw->dpy, curfont->xfont, utf8codepoint); 313 if (charexists) { 314 if (curfont == usedfont) { 315 utf8strlen += utf8charlen; 316 text += utf8charlen; 317 } else { 318 nextfont = curfont; 319 } 320 break; 321 } 322 } 323 324 if (!charexists || nextfont) 325 break; 326 else 327 charexists = 0; 328 } 329 330 if (utf8strlen) { 331 drw_font_getexts(usedfont, utf8str, utf8strlen, &ew, NULL); 332 /* shorten text if necessary */ 333 for (len = MIN(utf8strlen, sizeof(buf) - 1); len && ew > w; len--) 334 drw_font_getexts(usedfont, utf8str, len, &ew, NULL); 335 336 if (len) { 337 memcpy(buf, utf8str, len); 338 buf[len] = '\0'; 339 if (len < utf8strlen) 340 for (i = len; i && i > len - 3; buf[--i] = '.') 341 ; /* NOP */ 342 343 if (render) { 344 ty = y + (h - usedfont->h) / 2 + usedfont->xfont->ascent; 345 XftDrawStringUtf8(d, &drw->scheme[invert ? ColBg : ColFg], 346 usedfont->xfont, x, ty, (XftChar8 *)buf, len); 347 } 348 x += ew; 349 w -= ew; 350 } 351 } 352 353 if (!*text) { 354 break; 355 } else if (nextfont) { 356 charexists = 0; 357 usedfont = nextfont; 358 } else { 359 /* Regardless of whether or not a fallback font is found, the 360 * character must be drawn. */ 361 charexists = 1; 362 363 fccharset = FcCharSetCreate(); 364 FcCharSetAddChar(fccharset, utf8codepoint); 365 366 if (!drw->fonts->pattern) { 367 /* Refer to the comment in xfont_create for more information. */ 368 die("the first font in the cache must be loaded from a font string."); 369 } 370 371 fcpattern = FcPatternDuplicate(drw->fonts->pattern); 372 FcPatternAddCharSet(fcpattern, FC_CHARSET, fccharset); 373 FcPatternAddBool(fcpattern, FC_SCALABLE, FcTrue); 374 FcPatternAddBool(fcpattern, FC_COLOR, FcFalse); 375 376 FcConfigSubstitute(NULL, fcpattern, FcMatchPattern); 377 FcDefaultSubstitute(fcpattern); 378 match = XftFontMatch(drw->dpy, drw->screen, fcpattern, &result); 379 380 FcCharSetDestroy(fccharset); 381 FcPatternDestroy(fcpattern); 382 383 if (match) { 384 usedfont = xfont_create(drw, NULL, match); 385 if (usedfont && XftCharExists(drw->dpy, usedfont->xfont, utf8codepoint)) { 386 for (curfont = drw->fonts; curfont->next; curfont = curfont->next) 387 ; /* NOP */ 388 curfont->next = usedfont; 389 } else { 390 xfont_free(usedfont); 391 usedfont = drw->fonts; 392 } 393 } 394 } 395 } 396 if (d) 397 XftDrawDestroy(d); 398 399 return x + (render ? w : 0); 400 } 401 402 void 403 drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h) 404 { 405 if (!drw) 406 return; 407 408 XCopyArea(drw->dpy, drw->drawable, win, drw->gc, x, y, w, h, x, y); 409 XSync(drw->dpy, False); 410 } 411 412 unsigned int 413 drw_fontset_getwidth(Drw *drw, const char *text) 414 { 415 if (!drw || !drw->fonts || !text) 416 return 0; 417 return drw_text(drw, 0, 0, 0, 0, 0, text, 0); 418 } 419 420 void 421 drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned int *w, unsigned int *h) 422 { 423 XGlyphInfo ext; 424 425 if (!font || !text) 426 return; 427 428 XftTextExtentsUtf8(font->dpy, font->xfont, (XftChar8 *)text, len, &ext); 429 if (w) 430 *w = ext.xOff; 431 if (h) 432 *h = font->h; 433 } 434 435 Cur * 436 drw_cur_create(Drw *drw, int shape) 437 { 438 Cur *cur; 439 440 if (!drw || !(cur = ecalloc(1, sizeof(Cur)))) 441 return NULL; 442 443 cur->cursor = XCreateFontCursor(drw->dpy, shape); 444 445 return cur; 446 } 447 448 void 449 drw_cur_free(Drw *drw, Cur *cursor) 450 { 451 if (!cursor) 452 return; 453 454 XFreeCursor(drw->dpy, cursor->cursor); 455 free(cursor); 456 }