drw.c (11146B)
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 font = ecalloc(1, sizeof(Fnt)); 137 font->xfont = xfont; 138 font->pattern = pattern; 139 font->h = xfont->ascent + xfont->descent; 140 font->dpy = drw->dpy; 141 142 return font; 143 } 144 145 static void 146 xfont_free(Fnt *font) 147 { 148 if (!font) 149 return; 150 if (font->pattern) 151 FcPatternDestroy(font->pattern); 152 XftFontClose(font->dpy, font->xfont); 153 free(font); 154 } 155 156 Fnt* 157 drw_fontset_create(Drw* drw, const char *fonts[], size_t fontcount) 158 { 159 Fnt *cur, *ret = NULL; 160 size_t i; 161 162 if (!drw || !fonts) 163 return NULL; 164 165 for (i = 1; i <= fontcount; i++) { 166 if ((cur = xfont_create(drw, fonts[fontcount - i], NULL))) { 167 cur->next = ret; 168 ret = cur; 169 } 170 } 171 return (drw->fonts = ret); 172 } 173 174 void 175 drw_fontset_free(Fnt *font) 176 { 177 if (font) { 178 drw_fontset_free(font->next); 179 xfont_free(font); 180 } 181 } 182 183 void 184 drw_clr_create(Drw *drw, Clr *dest, const char *clrname) 185 { 186 if (!drw || !dest || !clrname) 187 return; 188 189 if (!XftColorAllocName(drw->dpy, DefaultVisual(drw->dpy, drw->screen), 190 DefaultColormap(drw->dpy, drw->screen), 191 clrname, dest)) 192 die("error, cannot allocate color '%s'", clrname); 193 } 194 195 /* Wrapper to create color schemes. The caller has to call free(3) on the 196 * returned color scheme when done using it. */ 197 Clr * 198 drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount) 199 { 200 size_t i; 201 Clr *ret; 202 203 /* need at least two colors for a scheme */ 204 if (!drw || !clrnames || clrcount < 2 || !(ret = ecalloc(clrcount, sizeof(XftColor)))) 205 return NULL; 206 207 for (i = 0; i < clrcount; i++) 208 drw_clr_create(drw, &ret[i], clrnames[i]); 209 return ret; 210 } 211 212 void 213 drw_setfontset(Drw *drw, Fnt *set) 214 { 215 if (drw) 216 drw->fonts = set; 217 } 218 219 void 220 drw_setscheme(Drw *drw, Clr *scm) 221 { 222 if (drw) 223 drw->scheme = scm; 224 } 225 226 void 227 drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int invert) 228 { 229 if (!drw || !drw->scheme) 230 return; 231 XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme[ColBg].pixel : drw->scheme[ColFg].pixel); 232 if (filled) 233 XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h); 234 else 235 XDrawRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w - 1, h - 1); 236 } 237 238 int 239 drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, unsigned int lpad, const char *text, int invert) 240 { 241 int ty, ellipsis_x = 0; 242 unsigned int tmpw, ew, ellipsis_w = 0, ellipsis_len, hash, h0, h1; 243 XftDraw *d = NULL; 244 Fnt *usedfont, *curfont, *nextfont; 245 int utf8strlen, utf8charlen, render = x || y || w || h; 246 long utf8codepoint = 0; 247 const char *utf8str; 248 FcCharSet *fccharset; 249 FcPattern *fcpattern; 250 FcPattern *match; 251 XftResult result; 252 int charexists = 0, overflow = 0; 253 /* keep track of a couple codepoints for which we have no match. */ 254 static unsigned int nomatches[128], ellipsis_width; 255 256 if (!drw || (render && (!drw->scheme || !w)) || !text || !drw->fonts) 257 return 0; 258 259 if (!render) { 260 w = invert ? invert : ~invert; 261 } else { 262 XSetForeground(drw->dpy, drw->gc, drw->scheme[invert ? ColFg : ColBg].pixel); 263 XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h); 264 d = XftDrawCreate(drw->dpy, drw->drawable, 265 DefaultVisual(drw->dpy, drw->screen), 266 DefaultColormap(drw->dpy, drw->screen)); 267 x += lpad; 268 w -= lpad; 269 } 270 271 usedfont = drw->fonts; 272 if (!ellipsis_width && render) 273 ellipsis_width = drw_fontset_getwidth(drw, "..."); 274 while (1) { 275 ew = ellipsis_len = utf8strlen = 0; 276 utf8str = text; 277 nextfont = NULL; 278 while (*text) { 279 utf8charlen = utf8decode(text, &utf8codepoint, UTF_SIZ); 280 for (curfont = drw->fonts; curfont; curfont = curfont->next) { 281 charexists = charexists || XftCharExists(drw->dpy, curfont->xfont, utf8codepoint); 282 if (charexists) { 283 drw_font_getexts(curfont, text, utf8charlen, &tmpw, NULL); 284 if (ew + ellipsis_width <= w) { 285 /* keep track where the ellipsis still fits */ 286 ellipsis_x = x + ew; 287 ellipsis_w = w - ew; 288 ellipsis_len = utf8strlen; 289 } 290 291 if (ew + tmpw > w) { 292 overflow = 1; 293 /* called from drw_fontset_getwidth_clamp(): 294 * it wants the width AFTER the overflow 295 */ 296 if (!render) 297 x += tmpw; 298 else 299 utf8strlen = ellipsis_len; 300 } else if (curfont == usedfont) { 301 utf8strlen += utf8charlen; 302 text += utf8charlen; 303 ew += tmpw; 304 } else { 305 nextfont = curfont; 306 } 307 break; 308 } 309 } 310 311 if (overflow || !charexists || nextfont) 312 break; 313 else 314 charexists = 0; 315 } 316 317 if (utf8strlen) { 318 if (render) { 319 ty = y + (h - usedfont->h) / 2 + usedfont->xfont->ascent; 320 XftDrawStringUtf8(d, &drw->scheme[invert ? ColBg : ColFg], 321 usedfont->xfont, x, ty, (XftChar8 *)utf8str, utf8strlen); 322 } 323 x += ew; 324 w -= ew; 325 } 326 if (render && overflow) 327 drw_text(drw, ellipsis_x, y, ellipsis_w, h, 0, "...", invert); 328 329 if (!*text || overflow) { 330 break; 331 } else if (nextfont) { 332 charexists = 0; 333 usedfont = nextfont; 334 } else { 335 /* Regardless of whether or not a fallback font is found, the 336 * character must be drawn. */ 337 charexists = 1; 338 339 hash = (unsigned int)utf8codepoint; 340 hash = ((hash >> 16) ^ hash) * 0x21F0AAAD; 341 hash = ((hash >> 15) ^ hash) * 0xD35A2D97; 342 h0 = ((hash >> 15) ^ hash) % LENGTH(nomatches); 343 h1 = (hash >> 17) % LENGTH(nomatches); 344 /* avoid expensive XftFontMatch call when we know we won't find a match */ 345 if (nomatches[h0] == utf8codepoint || nomatches[h1] == utf8codepoint) 346 goto no_match; 347 348 fccharset = FcCharSetCreate(); 349 FcCharSetAddChar(fccharset, utf8codepoint); 350 351 if (!drw->fonts->pattern) { 352 /* Refer to the comment in xfont_create for more information. */ 353 die("the first font in the cache must be loaded from a font string."); 354 } 355 356 fcpattern = FcPatternDuplicate(drw->fonts->pattern); 357 FcPatternAddCharSet(fcpattern, FC_CHARSET, fccharset); 358 FcPatternAddBool(fcpattern, FC_SCALABLE, FcTrue); 359 360 FcConfigSubstitute(NULL, fcpattern, FcMatchPattern); 361 FcDefaultSubstitute(fcpattern); 362 match = XftFontMatch(drw->dpy, drw->screen, fcpattern, &result); 363 364 FcCharSetDestroy(fccharset); 365 FcPatternDestroy(fcpattern); 366 367 if (match) { 368 usedfont = xfont_create(drw, NULL, match); 369 if (usedfont && XftCharExists(drw->dpy, usedfont->xfont, utf8codepoint)) { 370 for (curfont = drw->fonts; curfont->next; curfont = curfont->next) 371 ; /* NOP */ 372 curfont->next = usedfont; 373 } else { 374 xfont_free(usedfont); 375 nomatches[nomatches[h0] ? h1 : h0] = utf8codepoint; 376 no_match: 377 usedfont = drw->fonts; 378 } 379 } 380 } 381 } 382 if (d) 383 XftDrawDestroy(d); 384 385 return x + (render ? w : 0); 386 } 387 388 void 389 drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h) 390 { 391 if (!drw) 392 return; 393 394 XCopyArea(drw->dpy, drw->drawable, win, drw->gc, x, y, w, h, x, y); 395 XSync(drw->dpy, False); 396 } 397 398 unsigned int 399 drw_fontset_getwidth(Drw *drw, const char *text) 400 { 401 if (!drw || !drw->fonts || !text) 402 return 0; 403 return drw_text(drw, 0, 0, 0, 0, 0, text, 0); 404 } 405 406 unsigned int 407 drw_fontset_getwidth_clamp(Drw *drw, const char *text, unsigned int n) 408 { 409 unsigned int tmp = 0; 410 if (drw && drw->fonts && text && n) 411 tmp = drw_text(drw, 0, 0, 0, 0, 0, text, n); 412 return MIN(n, tmp); 413 } 414 415 void 416 drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned int *w, unsigned int *h) 417 { 418 XGlyphInfo ext; 419 420 if (!font || !text) 421 return; 422 423 XftTextExtentsUtf8(font->dpy, font->xfont, (XftChar8 *)text, len, &ext); 424 if (w) 425 *w = ext.xOff; 426 if (h) 427 *h = font->h; 428 } 429 430 Cur * 431 drw_cur_create(Drw *drw, int shape) 432 { 433 Cur *cur; 434 435 if (!drw || !(cur = ecalloc(1, sizeof(Cur)))) 436 return NULL; 437 438 cur->cursor = XCreateFontCursor(drw->dpy, shape); 439 440 return cur; 441 } 442 443 void 444 drw_cur_free(Drw *drw, Cur *cursor) 445 { 446 if (!cursor) 447 return; 448 449 XFreeCursor(drw->dpy, cursor->cursor); 450 free(cursor); 451 }