mirror of
https://github.com/mintycube/dmenu.git
synced 2024-10-18 14:05:53 +02:00
d66c96ba0b
this changes the utf8decode function to: * report when an error occurs * report how many bytes to advance on error these will be useful in the next commit to render invalid utf8 sequences. the new implementation is also shorter and more direct. ref. https://git.suckless.org/dmenu/commit/51e32d49b56c86cd288c64fccf6cd765547781b9.html
698 lines
17 KiB
C
698 lines
17 KiB
C
/* See LICENSE file for copyright and license details. */
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <X11/Xlib.h>
|
|
#include <X11/Xft/Xft.h>
|
|
|
|
#include "patches.h"
|
|
#include "drw.h"
|
|
#include "util.h"
|
|
|
|
#if !PANGO_PATCH || HIGHLIGHT_PATCH
|
|
#define UTF_INVALID 0xFFFD
|
|
|
|
static int
|
|
utf8decode(const char *s_in, long *u, int *err)
|
|
{
|
|
static const unsigned char lens[] = {
|
|
/* 0XXXX */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
/* 10XXX */ 0, 0, 0, 0, 0, 0, 0, 0, /* invalid */
|
|
/* 110XX */ 2, 2, 2, 2,
|
|
/* 1110X */ 3, 3,
|
|
/* 11110 */ 4,
|
|
/* 11111 */ 0, /* invalid */
|
|
};
|
|
static const unsigned char leading_mask[] = { 0x7F, 0x1F, 0x0F, 0x07 };
|
|
static const unsigned int overlong[] = { 0x0, 0x80, 0x0800, 0x10000 };
|
|
|
|
const unsigned char *s = (const unsigned char *)s_in;
|
|
int len = lens[*s >> 3];
|
|
*u = UTF_INVALID;
|
|
*err = 1;
|
|
if (len == 0)
|
|
return 1;
|
|
|
|
long cp = s[0] & leading_mask[len - 1];
|
|
for (int i = 1; i < len; ++i) {
|
|
if (s[i] == '\0' || (s[i] & 0xC0) != 0x80)
|
|
return i;
|
|
cp = (cp << 6) | (s[i] & 0x3F);
|
|
}
|
|
/* out of range, surrogate, overlong encoding */
|
|
if (cp > 0x10FFFF || (cp >> 11) == 0x1B || cp < overlong[len - 1])
|
|
return len;
|
|
|
|
*err = 0;
|
|
*u = cp;
|
|
return len;
|
|
}
|
|
|
|
#if HIGHLIGHT_PATCH
|
|
int
|
|
utf8len(const char *c)
|
|
{
|
|
long utf8codepoint = 0;
|
|
int utf8err = 0;
|
|
return utf8decode(c, &utf8codepoint, &utf8err);
|
|
}
|
|
#endif // HIGHLIGHT_PATCH
|
|
#endif // PANGO_PATCH
|
|
|
|
Drw *
|
|
#if ALPHA_PATCH
|
|
drw_create(Display *dpy, int screen, Window root, unsigned int w, unsigned int h, Visual *visual, unsigned int depth, Colormap cmap)
|
|
#else
|
|
drw_create(Display *dpy, int screen, Window root, unsigned int w, unsigned int h)
|
|
#endif // ALPHA_PATCH
|
|
{
|
|
Drw *drw = ecalloc(1, sizeof(Drw));
|
|
|
|
drw->dpy = dpy;
|
|
drw->screen = screen;
|
|
drw->root = root;
|
|
drw->w = w;
|
|
drw->h = h;
|
|
#if ALPHA_PATCH
|
|
drw->visual = visual;
|
|
drw->depth = depth;
|
|
drw->cmap = cmap;
|
|
drw->drawable = XCreatePixmap(dpy, root, w, h, depth);
|
|
drw->gc = XCreateGC(dpy, drw->drawable, 0, NULL);
|
|
#else
|
|
drw->drawable = XCreatePixmap(dpy, root, w, h, DefaultDepth(dpy, screen));
|
|
drw->gc = XCreateGC(dpy, root, 0, NULL);
|
|
#endif // ALPHA_PATCH
|
|
XSetLineAttributes(dpy, drw->gc, 1, LineSolid, CapButt, JoinMiter);
|
|
|
|
return drw;
|
|
}
|
|
|
|
void
|
|
drw_resize(Drw *drw, unsigned int w, unsigned int h)
|
|
{
|
|
if (!drw)
|
|
return;
|
|
|
|
drw->w = w;
|
|
drw->h = h;
|
|
if (drw->drawable)
|
|
XFreePixmap(drw->dpy, drw->drawable);
|
|
#if ALPHA_PATCH
|
|
drw->drawable = XCreatePixmap(drw->dpy, drw->root, w, h, drw->depth);
|
|
#else
|
|
drw->drawable = XCreatePixmap(drw->dpy, drw->root, w, h, DefaultDepth(drw->dpy, drw->screen));
|
|
#endif // ALPHA_PATCH
|
|
}
|
|
|
|
void
|
|
drw_free(Drw *drw)
|
|
{
|
|
XFreePixmap(drw->dpy, drw->drawable);
|
|
XFreeGC(drw->dpy, drw->gc);
|
|
#if PANGO_PATCH
|
|
drw_font_free(drw->font);
|
|
#else
|
|
drw_fontset_free(drw->fonts);
|
|
#endif // PANGO_PATCH
|
|
free(drw);
|
|
}
|
|
|
|
#if PANGO_PATCH
|
|
/* This function is an implementation detail. Library users should use
|
|
* drw_font_create instead.
|
|
*/
|
|
static Fnt *
|
|
xfont_create(Drw *drw, const char *fontname)
|
|
{
|
|
Fnt *font;
|
|
PangoFontMap *fontmap;
|
|
PangoContext *context;
|
|
PangoFontDescription *desc;
|
|
PangoFontMetrics *metrics;
|
|
|
|
if (!fontname) {
|
|
die("no font specified.");
|
|
}
|
|
|
|
font = ecalloc(1, sizeof(Fnt));
|
|
font->dpy = drw->dpy;
|
|
|
|
fontmap = pango_xft_get_font_map(drw->dpy, drw->screen);
|
|
context = pango_font_map_create_context(fontmap);
|
|
desc = pango_font_description_from_string(fontname);
|
|
font->layout = pango_layout_new(context);
|
|
pango_layout_set_font_description(font->layout, desc);
|
|
|
|
metrics = pango_context_get_metrics(context, desc, pango_language_from_string ("en-us"));
|
|
font->h = pango_font_metrics_get_height(metrics) / PANGO_SCALE;
|
|
|
|
pango_font_metrics_unref(metrics);
|
|
g_object_unref(context);
|
|
|
|
return font;
|
|
}
|
|
#else
|
|
/* This function is an implementation detail. Library users should use
|
|
* drw_fontset_create instead.
|
|
*/
|
|
static Fnt *
|
|
xfont_create(Drw *drw, const char *fontname, FcPattern *fontpattern)
|
|
{
|
|
Fnt *font;
|
|
XftFont *xfont = NULL;
|
|
FcPattern *pattern = NULL;
|
|
|
|
if (fontname) {
|
|
/* Using the pattern found at font->xfont->pattern does not yield the
|
|
* same substitution results as using the pattern returned by
|
|
* FcNameParse; using the latter results in the desired fallback
|
|
* behaviour whereas the former just results in missing-character
|
|
* rectangles being drawn, at least with some fonts. */
|
|
if (!(xfont = XftFontOpenName(drw->dpy, drw->screen, fontname))) {
|
|
fprintf(stderr, "error, cannot load font from name: '%s'\n", fontname);
|
|
return NULL;
|
|
}
|
|
if (!(pattern = FcNameParse((FcChar8 *) fontname))) {
|
|
fprintf(stderr, "error, cannot parse font name to pattern: '%s'\n", fontname);
|
|
XftFontClose(drw->dpy, xfont);
|
|
return NULL;
|
|
}
|
|
} else if (fontpattern) {
|
|
if (!(xfont = XftFontOpenPattern(drw->dpy, fontpattern))) {
|
|
fprintf(stderr, "error, cannot load font from pattern.\n");
|
|
return NULL;
|
|
}
|
|
} else {
|
|
die("no font specified.");
|
|
}
|
|
|
|
#if NO_COLOR_EMOJI_PATCH
|
|
/* Do not allow using color fonts. This is a workaround for a BadLength
|
|
* error from Xft with color glyphs. Modelled on the Xterm workaround. See
|
|
* https://bugzilla.redhat.com/show_bug.cgi?id=1498269
|
|
* https://lists.suckless.org/dev/1701/30932.html
|
|
* https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=916349
|
|
* and lots more all over the internet.
|
|
*/
|
|
FcBool iscol;
|
|
if (FcPatternGetBool(xfont->pattern, FC_COLOR, 0, &iscol) == FcResultMatch && iscol) {
|
|
XftFontClose(drw->dpy, xfont);
|
|
return NULL;
|
|
}
|
|
#endif // NO_COLOR_EMOJI_PATCH
|
|
|
|
font = ecalloc(1, sizeof(Fnt));
|
|
font->xfont = xfont;
|
|
font->pattern = pattern;
|
|
font->h = xfont->ascent + xfont->descent;
|
|
font->dpy = drw->dpy;
|
|
|
|
return font;
|
|
}
|
|
#endif // PANGO_PATCH
|
|
|
|
static void
|
|
xfont_free(Fnt *font)
|
|
{
|
|
if (!font)
|
|
return;
|
|
#if PANGO_PATCH
|
|
if (font->layout)
|
|
g_object_unref(font->layout);
|
|
#else
|
|
if (font->pattern)
|
|
FcPatternDestroy(font->pattern);
|
|
XftFontClose(font->dpy, font->xfont);
|
|
#endif // PANGO_PATCH
|
|
free(font);
|
|
}
|
|
|
|
#if PANGO_PATCH
|
|
Fnt*
|
|
drw_font_create(Drw* drw, const char *font)
|
|
{
|
|
Fnt *fnt = NULL;
|
|
|
|
if (!drw || !font)
|
|
return NULL;
|
|
|
|
fnt = xfont_create(drw, font);
|
|
|
|
return (drw->font = fnt);
|
|
}
|
|
#else
|
|
Fnt*
|
|
drw_fontset_create(Drw* drw, const char *fonts[], size_t fontcount)
|
|
{
|
|
Fnt *cur, *ret = NULL;
|
|
size_t i;
|
|
|
|
if (!drw || !fonts)
|
|
return NULL;
|
|
|
|
for (i = 1; i <= fontcount; i++) {
|
|
if ((cur = xfont_create(drw, fonts[fontcount - i], NULL))) {
|
|
cur->next = ret;
|
|
ret = cur;
|
|
}
|
|
}
|
|
return (drw->fonts = ret);
|
|
}
|
|
#endif // PANGO_PATCH
|
|
|
|
#if PANGO_PATCH
|
|
void
|
|
drw_font_free(Fnt *font)
|
|
{
|
|
if (font)
|
|
xfont_free(font);
|
|
}
|
|
#else
|
|
void
|
|
drw_fontset_free(Fnt *font)
|
|
{
|
|
if (font) {
|
|
drw_fontset_free(font->next);
|
|
xfont_free(font);
|
|
}
|
|
}
|
|
#endif // PANGO_PATCH
|
|
|
|
void
|
|
#if ALPHA_PATCH
|
|
drw_clr_create(Drw *drw, Clr *dest, const char *clrname, unsigned int alpha)
|
|
#else
|
|
drw_clr_create(Drw *drw, Clr *dest, const char *clrname)
|
|
#endif // ALPHA_PATCH
|
|
{
|
|
if (!drw || !dest || !clrname)
|
|
return;
|
|
|
|
#if ALPHA_PATCH
|
|
if (!XftColorAllocName(drw->dpy, drw->visual, drw->cmap,
|
|
clrname, dest))
|
|
die("error, cannot allocate color '%s'", clrname);
|
|
|
|
dest->pixel = (dest->pixel & 0x00ffffffU) | (alpha << 24);
|
|
#else
|
|
if (!XftColorAllocName(drw->dpy, DefaultVisual(drw->dpy, drw->screen),
|
|
DefaultColormap(drw->dpy, drw->screen),
|
|
clrname, dest))
|
|
die("error, cannot allocate color '%s'", clrname);
|
|
#endif // ALPHA_PATCH
|
|
}
|
|
|
|
/* Wrapper to create color schemes. The caller has to call free(3) on the
|
|
* returned color scheme when done using it. */
|
|
Clr *
|
|
#if ALPHA_PATCH
|
|
drw_scm_create(Drw *drw, const char *clrnames[], const unsigned int alphas[], size_t clrcount)
|
|
#else
|
|
drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount)
|
|
#endif // ALPHA_PATCH
|
|
{
|
|
size_t i;
|
|
Clr *ret;
|
|
|
|
/* need at least two colors for a scheme */
|
|
if (!drw || !clrnames || clrcount < 2 || !(ret = ecalloc(clrcount, sizeof(XftColor))))
|
|
return NULL;
|
|
|
|
for (i = 0; i < clrcount; i++)
|
|
#if ALPHA_PATCH
|
|
drw_clr_create(drw, &ret[i], clrnames[i], alphas[i]);
|
|
#else
|
|
drw_clr_create(drw, &ret[i], clrnames[i]);
|
|
#endif // ALPHA_PATCH
|
|
return ret;
|
|
}
|
|
|
|
#if !PANGO_PATCH
|
|
void
|
|
drw_setfontset(Drw *drw, Fnt *set)
|
|
{
|
|
if (drw)
|
|
drw->fonts = set;
|
|
}
|
|
#endif // PANGO_PATCH
|
|
|
|
void
|
|
drw_setscheme(Drw *drw, Clr *scm)
|
|
{
|
|
if (drw)
|
|
drw->scheme = scm;
|
|
}
|
|
|
|
void
|
|
drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int invert)
|
|
{
|
|
if (!drw || !drw->scheme)
|
|
return;
|
|
XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme[ColBg].pixel : drw->scheme[ColFg].pixel);
|
|
if (filled)
|
|
XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
|
|
else
|
|
XDrawRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w - 1, h - 1);
|
|
}
|
|
|
|
#if PANGO_PATCH
|
|
int
|
|
drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, unsigned int lpad, const char *text, int invert, Bool markup)
|
|
{
|
|
char buf[1024];
|
|
int i, ty, th;
|
|
unsigned int ew, eh;
|
|
XftDraw *d = NULL;
|
|
size_t len;
|
|
int render = x || y || w || h;
|
|
|
|
if (!drw || (render && !drw->scheme) || !text || !drw->font)
|
|
return 0;
|
|
|
|
if (!render) {
|
|
w = invert ? invert : ~invert;
|
|
} else {
|
|
XSetForeground(drw->dpy, drw->gc, drw->scheme[invert ? ColFg : ColBg].pixel);
|
|
XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
|
|
#if ALPHA_PATCH
|
|
d = XftDrawCreate(drw->dpy, drw->drawable, drw->visual, drw->cmap);
|
|
#else
|
|
d = XftDrawCreate(drw->dpy, drw->drawable,
|
|
DefaultVisual(drw->dpy, drw->screen),
|
|
DefaultColormap(drw->dpy, drw->screen));
|
|
#endif // ALPHA_PATCH
|
|
x += lpad;
|
|
w -= lpad;
|
|
}
|
|
|
|
len = strlen(text);
|
|
|
|
if (len) {
|
|
drw_font_getexts(drw->font, text, len, &ew, &eh, markup);
|
|
th = eh;
|
|
/* shorten text if necessary */
|
|
for (len = MIN(len, sizeof(buf) - 1); len && ew > w; len--) {
|
|
drw_font_getexts(drw->font, text, len, &ew, &eh, markup);
|
|
if (eh > th)
|
|
th = eh;
|
|
}
|
|
|
|
if (len) {
|
|
memcpy(buf, text, len);
|
|
buf[len] = '\0';
|
|
if (len < strlen(text))
|
|
for (i = len; i && i > len - 3; buf[--i] = '.')
|
|
; /* NOP */
|
|
|
|
if (render) {
|
|
ty = y + (h - th) / 2;
|
|
if (markup)
|
|
pango_layout_set_markup(drw->font->layout, buf, len);
|
|
else
|
|
pango_layout_set_text(drw->font->layout, buf, len);
|
|
pango_xft_render_layout(d, &drw->scheme[invert ? ColBg : ColFg],
|
|
drw->font->layout, x * PANGO_SCALE, ty * PANGO_SCALE);
|
|
if (markup) /* clear markup attributes */
|
|
pango_layout_set_attributes(drw->font->layout, NULL);
|
|
}
|
|
x += ew;
|
|
w -= ew;
|
|
}
|
|
}
|
|
|
|
if (d)
|
|
XftDrawDestroy(d);
|
|
|
|
return x + (render ? w : 0);
|
|
}
|
|
#else
|
|
int
|
|
drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, unsigned int lpad, const char *text, int invert)
|
|
{
|
|
int ty, ellipsis_x = 0;
|
|
unsigned int tmpw, ew, ellipsis_w = 0, ellipsis_len, hash, h0, h1;
|
|
XftDraw *d = NULL;
|
|
Fnt *usedfont, *curfont, *nextfont;
|
|
int utf8strlen, utf8charlen, utf8err, render = x || y || w || h;
|
|
long utf8codepoint = 0;
|
|
const char *utf8str;
|
|
FcCharSet *fccharset;
|
|
FcPattern *fcpattern;
|
|
FcPattern *match;
|
|
XftResult result;
|
|
int charexists = 0, overflow = 0;
|
|
/* keep track of a couple codepoints for which we have no match. */
|
|
static unsigned int nomatches[128], ellipsis_width;
|
|
const char *ellipsis = "...";
|
|
|
|
if (!drw || (render && (!drw->scheme || !w)) || !text || !drw->fonts)
|
|
return 0;
|
|
|
|
if (!render) {
|
|
w = invert ? invert : ~invert;
|
|
} else {
|
|
XSetForeground(drw->dpy, drw->gc, drw->scheme[invert ? ColFg : ColBg].pixel);
|
|
XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
|
|
#if ALPHA_PATCH
|
|
d = XftDrawCreate(drw->dpy, drw->drawable, drw->visual, drw->cmap);
|
|
#else
|
|
d = XftDrawCreate(drw->dpy, drw->drawable,
|
|
DefaultVisual(drw->dpy, drw->screen),
|
|
DefaultColormap(drw->dpy, drw->screen));
|
|
#endif // ALPHA_PATCH
|
|
x += lpad;
|
|
w -= lpad;
|
|
}
|
|
|
|
usedfont = drw->fonts;
|
|
if (!ellipsis_width && render)
|
|
ellipsis_width = drw_fontset_getwidth(drw, ellipsis);
|
|
while (1) {
|
|
ew = ellipsis_len = utf8err = utf8strlen = 0;
|
|
utf8str = text;
|
|
nextfont = NULL;
|
|
while (*text) {
|
|
utf8charlen = utf8decode(text, &utf8codepoint, &utf8err);
|
|
for (curfont = drw->fonts; curfont; curfont = curfont->next) {
|
|
charexists = charexists || XftCharExists(drw->dpy, curfont->xfont, utf8codepoint);
|
|
if (charexists) {
|
|
drw_font_getexts(curfont, text, utf8charlen, &tmpw, NULL);
|
|
if (ew + ellipsis_width <= w) {
|
|
/* keep track where the ellipsis still fits */
|
|
ellipsis_x = x + ew;
|
|
ellipsis_w = w - ew;
|
|
ellipsis_len = utf8strlen;
|
|
}
|
|
|
|
if (ew + tmpw > w) {
|
|
overflow = 1;
|
|
/* called from drw_fontset_getwidth_clamp():
|
|
* it wants the width AFTER the overflow
|
|
*/
|
|
if (!render)
|
|
x += tmpw;
|
|
else
|
|
utf8strlen = ellipsis_len;
|
|
} else if (curfont == usedfont) {
|
|
utf8strlen += utf8charlen;
|
|
text += utf8charlen;
|
|
ew += tmpw;
|
|
} else {
|
|
nextfont = curfont;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (overflow || !charexists || nextfont)
|
|
break;
|
|
else
|
|
charexists = 0;
|
|
}
|
|
|
|
if (utf8strlen) {
|
|
if (render) {
|
|
ty = y + (h - usedfont->h) / 2 + usedfont->xfont->ascent;
|
|
XftDrawStringUtf8(d, &drw->scheme[invert ? ColBg : ColFg],
|
|
usedfont->xfont, x, ty, (XftChar8 *)utf8str, utf8strlen);
|
|
}
|
|
x += ew;
|
|
w -= ew;
|
|
}
|
|
if (render && overflow && ellipsis_w)
|
|
drw_text(drw, ellipsis_x, y, ellipsis_w, h, 0, ellipsis, invert);
|
|
|
|
if (!*text || overflow) {
|
|
break;
|
|
} else if (nextfont) {
|
|
charexists = 0;
|
|
usedfont = nextfont;
|
|
} else {
|
|
/* Regardless of whether or not a fallback font is found, the
|
|
* character must be drawn. */
|
|
charexists = 1;
|
|
|
|
hash = (unsigned int)utf8codepoint;
|
|
hash = ((hash >> 16) ^ hash) * 0x21F0AAAD;
|
|
hash = ((hash >> 15) ^ hash) * 0xD35A2D97;
|
|
h0 = ((hash >> 15) ^ hash) % LENGTH(nomatches);
|
|
h1 = (hash >> 17) % LENGTH(nomatches);
|
|
/* avoid expensive XftFontMatch call when we know we won't find a match */
|
|
if (nomatches[h0] == utf8codepoint || nomatches[h1] == utf8codepoint)
|
|
goto no_match;
|
|
|
|
fccharset = FcCharSetCreate();
|
|
FcCharSetAddChar(fccharset, utf8codepoint);
|
|
|
|
if (!drw->fonts->pattern) {
|
|
/* Refer to the comment in xfont_create for more information. */
|
|
die("the first font in the cache must be loaded from a font string.");
|
|
}
|
|
|
|
fcpattern = FcPatternDuplicate(drw->fonts->pattern);
|
|
FcPatternAddCharSet(fcpattern, FC_CHARSET, fccharset);
|
|
FcPatternAddBool(fcpattern, FC_SCALABLE, FcTrue);
|
|
#if NO_COLOR_EMOJI_PATCH
|
|
FcPatternAddBool(fcpattern, FC_COLOR, FcFalse);
|
|
#endif // NO_COLOR_EMOJI_PATCH
|
|
|
|
FcConfigSubstitute(NULL, fcpattern, FcMatchPattern);
|
|
FcDefaultSubstitute(fcpattern);
|
|
match = XftFontMatch(drw->dpy, drw->screen, fcpattern, &result);
|
|
|
|
FcCharSetDestroy(fccharset);
|
|
FcPatternDestroy(fcpattern);
|
|
|
|
if (match) {
|
|
usedfont = xfont_create(drw, NULL, match);
|
|
if (usedfont && XftCharExists(drw->dpy, usedfont->xfont, utf8codepoint)) {
|
|
for (curfont = drw->fonts; curfont->next; curfont = curfont->next)
|
|
; /* NOP */
|
|
curfont->next = usedfont;
|
|
} else {
|
|
xfont_free(usedfont);
|
|
nomatches[nomatches[h0] ? h1 : h0] = utf8codepoint;
|
|
no_match:
|
|
usedfont = drw->fonts;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (d)
|
|
XftDrawDestroy(d);
|
|
|
|
return x + (render ? w : 0);
|
|
}
|
|
#endif // PANGO_PATCH
|
|
|
|
void
|
|
drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h)
|
|
{
|
|
if (!drw)
|
|
return;
|
|
|
|
XCopyArea(drw->dpy, drw->drawable, win, drw->gc, x, y, w, h, x, y);
|
|
XSync(drw->dpy, False);
|
|
}
|
|
|
|
#if PANGO_PATCH
|
|
unsigned int
|
|
drw_font_getwidth(Drw *drw, const char *text, Bool markup)
|
|
{
|
|
if (!drw || !drw->font || !text)
|
|
return 0;
|
|
return drw_text(drw, 0, 0, 0, 0, 0, text, 0, markup);
|
|
}
|
|
|
|
unsigned int
|
|
drw_fontset_getwidth_clamp(Drw *drw, const char *text, unsigned int n)
|
|
{
|
|
unsigned int tmp = 0;
|
|
if (drw && drw->font && text && n)
|
|
tmp = drw_text(drw, 0, 0, 0, 0, 0, text, n, True);
|
|
return MIN(n, tmp);
|
|
}
|
|
#else
|
|
unsigned int
|
|
drw_fontset_getwidth(Drw *drw, const char *text)
|
|
{
|
|
if (!drw || !drw->fonts || !text)
|
|
return 0;
|
|
return drw_text(drw, 0, 0, 0, 0, 0, text, 0);
|
|
}
|
|
|
|
unsigned int
|
|
drw_fontset_getwidth_clamp(Drw *drw, const char *text, unsigned int n)
|
|
{
|
|
unsigned int tmp = 0;
|
|
if (drw && drw->fonts && text && n)
|
|
tmp = drw_text(drw, 0, 0, 0, 0, 0, text, n);
|
|
return MIN(n, tmp);
|
|
}
|
|
#endif // PANGO_PATCH
|
|
|
|
#if PANGO_PATCH
|
|
void
|
|
drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned int *w, unsigned int *h, Bool markup)
|
|
{
|
|
if (!font || !text)
|
|
return;
|
|
|
|
PangoRectangle r;
|
|
if (markup)
|
|
pango_layout_set_markup(font->layout, text, len);
|
|
else
|
|
pango_layout_set_text(font->layout, text, len);
|
|
pango_layout_get_extents(font->layout, 0, &r);
|
|
if (markup) /* clear markup attributes */
|
|
pango_layout_set_attributes(font->layout, NULL);
|
|
if (w)
|
|
*w = r.width / PANGO_SCALE;
|
|
if (h)
|
|
*h = r.height / PANGO_SCALE;
|
|
}
|
|
#else
|
|
void
|
|
drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned int *w, unsigned int *h)
|
|
{
|
|
XGlyphInfo ext;
|
|
|
|
if (!font || !text)
|
|
return;
|
|
|
|
XftTextExtentsUtf8(font->dpy, font->xfont, (XftChar8 *)text, len, &ext);
|
|
if (w)
|
|
*w = ext.xOff;
|
|
if (h)
|
|
*h = font->h;
|
|
}
|
|
#endif // PANGO_PATCH
|
|
|
|
Cur *
|
|
drw_cur_create(Drw *drw, int shape)
|
|
{
|
|
Cur *cur;
|
|
|
|
if (!drw || !(cur = ecalloc(1, sizeof(Cur))))
|
|
return NULL;
|
|
|
|
cur->cursor = XCreateFontCursor(drw->dpy, shape);
|
|
|
|
return cur;
|
|
}
|
|
|
|
void
|
|
drw_cur_free(Drw *drw, Cur *cursor)
|
|
{
|
|
if (!cursor)
|
|
return;
|
|
|
|
XFreeCursor(drw->dpy, cursor->cursor);
|
|
free(cursor);
|
|
}
|
|
|
|
#if SCROLL_PATCH
|
|
#include "patch/scroll.c"
|
|
#endif
|