drw.c (11697B)
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 13 static int 14 utf8decode(const char *s_in, long *u, int *err) 15 { 16 static const unsigned char lens[] = { 17 /* 0XXXX */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 18 /* 10XXX */ 0, 0, 0, 0, 0, 0, 0, 0, /* invalid */ 19 /* 110XX */ 2, 2, 2, 2, 20 /* 1110X */ 3, 3, 21 /* 11110 */ 4, 22 /* 11111 */ 0, /* invalid */ 23 }; 24 static const unsigned char leading_mask[] = { 0x7F, 0x1F, 0x0F, 0x07 }; 25 static const unsigned int overlong[] = { 0x0, 0x80, 0x0800, 0x10000 }; 26 27 const unsigned char *s = (const unsigned char *)s_in; 28 int len = lens[*s >> 3]; 29 *u = UTF_INVALID; 30 *err = 1; 31 if (len == 0) 32 return 1; 33 34 long cp = s[0] & leading_mask[len - 1]; 35 for (int i = 1; i < len; ++i) { 36 if (s[i] == '\0' || (s[i] & 0xC0) != 0x80) 37 return i; 38 cp = (cp << 6) | (s[i] & 0x3F); 39 } 40 /* out of range, surrogate, overlong encoding */ 41 if (cp > 0x10FFFF || (cp >> 11) == 0x1B || cp < overlong[len - 1]) 42 return len; 43 44 *err = 0; 45 *u = cp; 46 return len; 47 } 48 49 Drw * 50 drw_create(Display *dpy, int screen, Window root, unsigned int w, unsigned int h) 51 { 52 Drw *drw = ecalloc(1, sizeof(Drw)); 53 54 drw->dpy = dpy; 55 drw->screen = screen; 56 drw->root = root; 57 drw->w = w; 58 drw->h = h; 59 drw->drawable = XCreatePixmap(dpy, root, w, h, DefaultDepth(dpy, screen)); 60 drw->gc = XCreateGC(dpy, root, 0, NULL); 61 XSetLineAttributes(dpy, drw->gc, 1, LineSolid, CapButt, JoinMiter); 62 63 return drw; 64 } 65 66 void 67 drw_resize(Drw *drw, unsigned int w, unsigned int h) 68 { 69 if (!drw) 70 return; 71 72 drw->w = w; 73 drw->h = h; 74 if (drw->drawable) 75 XFreePixmap(drw->dpy, drw->drawable); 76 drw->drawable = XCreatePixmap(drw->dpy, drw->root, w, h, DefaultDepth(drw->dpy, drw->screen)); 77 } 78 79 void 80 drw_free(Drw *drw) 81 { 82 XFreePixmap(drw->dpy, drw->drawable); 83 XFreeGC(drw->dpy, drw->gc); 84 drw_fontset_free(drw->fonts); 85 free(drw); 86 } 87 88 /* This function is an implementation detail. Library users should use 89 * drw_fontset_create instead. 90 */ 91 static Fnt * 92 xfont_create(Drw *drw, const char *fontname, FcPattern *fontpattern) 93 { 94 Fnt *font; 95 XftFont *xfont = NULL; 96 FcPattern *pattern = NULL; 97 98 if (fontname) { 99 /* Using the pattern found at font->xfont->pattern does not yield the 100 * same substitution results as using the pattern returned by 101 * FcNameParse; using the latter results in the desired fallback 102 * behaviour whereas the former just results in missing-character 103 * rectangles being drawn, at least with some fonts. */ 104 if (!(xfont = XftFontOpenName(drw->dpy, drw->screen, fontname))) { 105 fprintf(stderr, "error, cannot load font from name: '%s'\n", fontname); 106 return NULL; 107 } 108 if (!(pattern = FcNameParse((FcChar8 *) fontname))) { 109 fprintf(stderr, "error, cannot parse font name to pattern: '%s'\n", fontname); 110 XftFontClose(drw->dpy, xfont); 111 return NULL; 112 } 113 } else if (fontpattern) { 114 if (!(xfont = XftFontOpenPattern(drw->dpy, fontpattern))) { 115 fprintf(stderr, "error, cannot load font from pattern.\n"); 116 return NULL; 117 } 118 } else { 119 die("no font specified."); 120 } 121 122 font = ecalloc(1, sizeof(Fnt)); 123 font->xfont = xfont; 124 font->pattern = pattern; 125 font->h = xfont->ascent + xfont->descent; 126 font->dpy = drw->dpy; 127 128 return font; 129 } 130 131 static void 132 xfont_free(Fnt *font) 133 { 134 if (!font) 135 return; 136 if (font->pattern) 137 FcPatternDestroy(font->pattern); 138 XftFontClose(font->dpy, font->xfont); 139 free(font); 140 } 141 142 Fnt* 143 drw_fontset_create(Drw* drw, const char *fonts[], size_t fontcount) 144 { 145 Fnt *cur, *ret = NULL; 146 size_t i; 147 148 if (!drw || !fonts) 149 return NULL; 150 151 for (i = 1; i <= fontcount; i++) { 152 if ((cur = xfont_create(drw, fonts[fontcount - i], NULL))) { 153 cur->next = ret; 154 ret = cur; 155 } 156 } 157 return (drw->fonts = ret); 158 } 159 160 void 161 drw_fontset_free(Fnt *font) 162 { 163 if (font) { 164 drw_fontset_free(font->next); 165 xfont_free(font); 166 } 167 } 168 169 void 170 drw_clr_create(Drw *drw, Clr *dest, const char *clrname) 171 { 172 if (!drw || !dest || !clrname) 173 return; 174 175 if (!XftColorAllocName(drw->dpy, DefaultVisual(drw->dpy, drw->screen), 176 DefaultColormap(drw->dpy, drw->screen), 177 clrname, dest)) 178 die("error, cannot allocate color '%s'", clrname); 179 180 dest->pixel |= 0xff << 24; 181 } 182 183 /* Create color schemes. */ 184 Clr * 185 #if !XRDB 186 drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount) 187 #else 188 drw_scm_create(Drw *drw, char *clrnames[], size_t clrcount) 189 #endif 190 { 191 size_t i; 192 Clr *ret; 193 194 /* need at least two colors for a scheme */ 195 if (!drw || !clrnames || clrcount < 2 || !(ret = ecalloc(clrcount, sizeof(Clr)))) 196 return NULL; 197 198 for (i = 0; i < clrcount; i++) 199 drw_clr_create(drw, &ret[i], clrnames[i]); 200 return ret; 201 } 202 203 void 204 drw_clr_free(Drw *drw, Clr *c) 205 { 206 if (!drw || !c) 207 return; 208 209 /* c is typedef XftColor Clr */ 210 XftColorFree(drw->dpy, DefaultVisual(drw->dpy, drw->screen), 211 DefaultColormap(drw->dpy, drw->screen), c); 212 } 213 214 void 215 drw_scm_free(Drw *drw, Clr *scm, size_t clrcount) 216 { 217 size_t i; 218 219 if (!drw || !scm) 220 return; 221 222 for (i = 0; i < clrcount; i++) 223 drw_clr_free(drw, &scm[i]); 224 free(scm); 225 } 226 227 void 228 drw_setfontset(Drw *drw, Fnt *set) 229 { 230 if (drw) 231 drw->fonts = set; 232 } 233 234 void 235 drw_setscheme(Drw *drw, Clr *scm) 236 { 237 if (drw) 238 drw->scheme = scm; 239 } 240 241 void 242 drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int invert) 243 { 244 if (!drw || !drw->scheme) 245 return; 246 XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme[ColBg].pixel : drw->scheme[ColFg].pixel); 247 if (filled) 248 XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h); 249 else 250 XDrawRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w - 1, h - 1); 251 } 252 253 int 254 drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, unsigned int lpad, const char *text, int invert) 255 { 256 int ty, ellipsis_x = 0; 257 unsigned int tmpw, ew, ellipsis_w = 0, ellipsis_len, hash, h0, h1; 258 XftDraw *d = NULL; 259 Fnt *usedfont, *curfont, *nextfont; 260 int utf8strlen, utf8charlen, utf8err, render = x || y || w || h; 261 long utf8codepoint = 0; 262 const char *utf8str; 263 FcCharSet *fccharset; 264 FcPattern *fcpattern; 265 FcPattern *match; 266 XftResult result; 267 int charexists = 0, overflow = 0; 268 /* keep track of a couple codepoints for which we have no match. */ 269 static unsigned int nomatches[128], ellipsis_width, invalid_width; 270 static const char invalid[] = "�"; 271 272 if (!drw || (render && (!drw->scheme || !w)) || !text || !drw->fonts) 273 return 0; 274 275 if (!render) { 276 w = invert ? invert : ~invert; 277 } else { 278 XSetForeground(drw->dpy, drw->gc, drw->scheme[invert ? ColFg : ColBg].pixel); 279 XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h); 280 if (w < lpad) 281 return x + w; 282 d = XftDrawCreate(drw->dpy, drw->drawable, 283 DefaultVisual(drw->dpy, drw->screen), 284 DefaultColormap(drw->dpy, drw->screen)); 285 x += lpad; 286 w -= lpad; 287 } 288 289 usedfont = drw->fonts; 290 if (!ellipsis_width && render) 291 ellipsis_width = drw_fontset_getwidth(drw, "..."); 292 if (!invalid_width && render) 293 invalid_width = drw_fontset_getwidth(drw, invalid); 294 while (1) { 295 ew = ellipsis_len = utf8err = utf8charlen = utf8strlen = 0; 296 utf8str = text; 297 nextfont = NULL; 298 while (*text) { 299 utf8charlen = utf8decode(text, &utf8codepoint, &utf8err); 300 for (curfont = drw->fonts; curfont; curfont = curfont->next) { 301 charexists = charexists || XftCharExists(drw->dpy, curfont->xfont, utf8codepoint); 302 if (charexists) { 303 drw_font_getexts(curfont, text, utf8charlen, &tmpw, NULL); 304 if (ew + ellipsis_width <= w) { 305 /* keep track where the ellipsis still fits */ 306 ellipsis_x = x + ew; 307 ellipsis_w = w - ew; 308 ellipsis_len = utf8strlen; 309 } 310 311 if (ew + tmpw > w) { 312 overflow = 1; 313 /* called from drw_fontset_getwidth_clamp(): 314 * it wants the width AFTER the overflow 315 */ 316 if (!render) 317 x += tmpw; 318 else 319 utf8strlen = ellipsis_len; 320 } else if (curfont == usedfont) { 321 text += utf8charlen; 322 utf8strlen += utf8err ? 0 : utf8charlen; 323 ew += utf8err ? 0 : tmpw; 324 } else { 325 nextfont = curfont; 326 } 327 break; 328 } 329 } 330 331 if (overflow || !charexists || nextfont || utf8err) 332 break; 333 else 334 charexists = 0; 335 } 336 337 if (utf8strlen) { 338 if (render) { 339 ty = y + (h - usedfont->h) / 2 + usedfont->xfont->ascent; 340 XftDrawStringUtf8(d, &drw->scheme[invert ? ColBg : ColFg], 341 usedfont->xfont, x, ty, (XftChar8 *)utf8str, utf8strlen); 342 } 343 x += ew; 344 w -= ew; 345 } 346 if (utf8err && (!render || invalid_width < w)) { 347 if (render) 348 drw_text(drw, x, y, w, h, 0, invalid, invert); 349 x += invalid_width; 350 w -= invalid_width; 351 } 352 if (render && overflow) 353 drw_text(drw, ellipsis_x, y, ellipsis_w, h, 0, "...", invert); 354 355 if (!*text || overflow) { 356 break; 357 } else if (nextfont) { 358 charexists = 0; 359 usedfont = nextfont; 360 } else { 361 /* Regardless of whether or not a fallback font is found, the 362 * character must be drawn. */ 363 charexists = 1; 364 365 hash = (unsigned int)utf8codepoint; 366 hash = ((hash >> 16) ^ hash) * 0x21F0AAAD; 367 hash = ((hash >> 15) ^ hash) * 0xD35A2D97; 368 h0 = ((hash >> 15) ^ hash) % LENGTH(nomatches); 369 h1 = (hash >> 17) % LENGTH(nomatches); 370 /* avoid expensive XftFontMatch call when we know we won't find a match */ 371 if (nomatches[h0] == utf8codepoint || nomatches[h1] == utf8codepoint) 372 goto no_match; 373 374 fccharset = FcCharSetCreate(); 375 FcCharSetAddChar(fccharset, utf8codepoint); 376 377 if (!drw->fonts->pattern) { 378 /* Refer to the comment in xfont_create for more information. */ 379 die("the first font in the cache must be loaded from a font string."); 380 } 381 382 fcpattern = FcPatternDuplicate(drw->fonts->pattern); 383 FcPatternAddCharSet(fcpattern, FC_CHARSET, fccharset); 384 FcPatternAddBool(fcpattern, FC_SCALABLE, FcTrue); 385 386 FcConfigSubstitute(NULL, fcpattern, FcMatchPattern); 387 FcDefaultSubstitute(fcpattern); 388 match = XftFontMatch(drw->dpy, drw->screen, fcpattern, &result); 389 390 FcCharSetDestroy(fccharset); 391 FcPatternDestroy(fcpattern); 392 393 if (match) { 394 usedfont = xfont_create(drw, NULL, match); 395 if (usedfont && XftCharExists(drw->dpy, usedfont->xfont, utf8codepoint)) { 396 for (curfont = drw->fonts; curfont->next; curfont = curfont->next) 397 ; /* NOP */ 398 curfont->next = usedfont; 399 } else { 400 xfont_free(usedfont); 401 nomatches[nomatches[h0] ? h1 : h0] = utf8codepoint; 402 no_match: 403 usedfont = drw->fonts; 404 } 405 } 406 } 407 } 408 if (d) 409 XftDrawDestroy(d); 410 411 return x + (render ? w : 0); 412 } 413 414 void 415 drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h) 416 { 417 if (!drw) 418 return; 419 420 XCopyArea(drw->dpy, drw->drawable, win, drw->gc, x, y, w, h, x, y); 421 XSync(drw->dpy, False); 422 } 423 424 unsigned int 425 drw_fontset_getwidth(Drw *drw, const char *text) 426 { 427 if (!drw || !drw->fonts || !text) 428 return 0; 429 return drw_text(drw, 0, 0, 0, 0, 0, text, 0); 430 } 431 432 unsigned int 433 drw_fontset_getwidth_clamp(Drw *drw, const char *text, unsigned int n) 434 { 435 unsigned int tmp = 0; 436 if (drw && drw->fonts && text && n) 437 tmp = drw_text(drw, 0, 0, 0, 0, 0, text, n); 438 return MIN(n, tmp); 439 } 440 441 void 442 drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned int *w, unsigned int *h) 443 { 444 XGlyphInfo ext; 445 446 if (!font || !text) 447 return; 448 449 XftTextExtentsUtf8(font->dpy, font->xfont, (XftChar8 *)text, len, &ext); 450 if (w) 451 *w = ext.xOff; 452 if (h) 453 *h = font->h; 454 } 455 456 Cur * 457 drw_cur_create(Drw *drw, int shape) 458 { 459 Cur *cur; 460 461 if (!drw || !(cur = ecalloc(1, sizeof(Cur)))) 462 return NULL; 463 464 cur->cursor = XCreateFontCursor(drw->dpy, shape); 465 466 return cur; 467 } 468 469 void 470 drw_cur_free(Drw *drw, Cur *cursor) 471 { 472 if (!cursor) 473 return; 474 475 XFreeCursor(drw->dpy, cursor->cursor); 476 free(cursor); 477 }