c
复制代码
// gcc -o dmenux dmenux.c `pkg-config --cflags --libs freetype2` -lX11 -lXft -lfontconfig -DXINERAMA -lXinerama -Wall -Wextra -pedantic
#include <stddef.h>
#include <errno.h>
#include <stdarg.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <locale.h>
#include <strings.h>
#include <time.h>
#include <unistd.h>
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#ifdef XINERAMA
#include <X11/extensions/Xinerama.h>
#endif
#include <X11/Xft/Xft.h>
extern char *argv0;
#define ARGBEGIN \
for (argv0 = *argv, argv++, argc--; \
argv[0] && argv[0][0] == '-' && argv[0][1]; \
argc--, argv++) \
{ \
char argc_; \
char **argv_; \
int brk_; \
if (argv[0][1] == '-' && argv[0][2] == '\0') \
{ \
argv++; \
argc--; \
break; \
} \
for (brk_ = 0, argv[0]++, argv_ = argv; \
argv[0][0] && !brk_; \
argv[0]++) \
{ \
if (argv_ != argv) \
break; \
argc_ = argv[0][0]; \
switch (argc_)
#define ARGEND \
} \
}
#define ARGC() argc_
#define EARGF(x) ((argv[0][1] == '\0' && argv[1] == NULL) ? ((x), abort(), (char *)0) : (brk_ = 1, (argv[0][1] != '\0') ? (&argv[0][1]) : (argc--, argv++, argv[0])))
#define ARGF() ((argv[0][1] == '\0' && argv[1] == NULL) ? (char *)0 : (brk_ = 1, (argv[0][1] != '\0') ? (&argv[0][1]) : (argc--, argv++, argv[0])))
enum
{
SchemeNorm,
SchemeSel,
SchemeOut,
SchemeLast
};
#if 0
static int topbar = 0;
static const char *fonts[] = {
"monospace:size=10"
};
static const char *prompt = NULL;
static const char *colors[SchemeLast][2] = {
[SchemeNorm] = {"#bbbbbb", "#222222"},
[SchemeSel] = {"#eeeeee", "#005577"},
[SchemeOut] = {"#000000", "#00ffff"},
};
static unsigned int lines = 0;
static const char worddelimiters[] = " ";
#else
static int topbar = 0;
static const char *fonts[] = {
"Noto Sans:size=40", // 通用无衬线字体，支持多语言
"Roboto:size=40", // 现代简洁字体
"Helvetica Neue:size=40", // 经典无衬线字体
"Arial:size=40", // 系统常用字体
"sans-serif:size=40", // 系统默认字体 fallback
"WenQuanYi Micro Hei:size=40", // 中文字体支持
"SimHei:size=40", // 中文字体 fallback
};
// bugfix(etcix): use my utf8decode to support this prompt text not cause seg fault
// static const char *prompt = "¯\\_(ツ)_/¯";
static const char *prompt = "❯ ";
static const char *colors[SchemeLast][2] = {
[SchemeNorm] = {"#f8f8f2", "#282a36"}, // 浅灰文字，深紫背景（类似Dracula主题）
[SchemeSel] = {"#ffffff", "#bd93f9"}, // 白色文字，紫色高亮（选中项）
[SchemeOut] = {"#282a36", "#50fa7b"}, // 深色文字，绿色背景（已输出项）
};
static unsigned int lines = 5;
static const char worddelimiters[] = " /?\"&[](){}<>|;:,.!@#$%^&*~";
#endif
#define MAX(A, B) ((A) > (B) ? (A) : (B))
#define MIN(A, B) ((A) < (B) ? (A) : (B))
#define BETWEEN(X, A, B) ((A) <= (X) && (X) <= (B))
#define LENGTH(X) (sizeof(X) / sizeof(X)[0])
void die(const char *fmt, ...);
void *ecalloc(size_t nmemb, size_t size);
void die(const char *fmt, ...)
{
va_list ap;
int saved_errno;
saved_errno = errno;
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
if (fmt[0] && fmt[strlen(fmt) - 1] == ':')
fprintf(stderr, " %s", strerror(saved_errno));
fputc('\n', stderr);
exit(1);
}
void *
ecalloc(size_t nmemb, size_t size)
{
void *p;
if (!(p = calloc(nmemb, size)))
die("calloc:");
return p;
}
typedef struct
{
Cursor cursor;
} Cur;
typedef struct Fnt
{
Display *dpy;
unsigned int h;
XftFont *xfont;
FcPattern *pattern;
struct Fnt *next;
} Fnt;
enum
{
ColFg,
ColBg
};
typedef XftColor Clr;
typedef struct
{
unsigned int w, h;
Display *dpy;
int screen;
Window root;
Drawable drawable;
GC gc;
Clr *scheme;
Fnt *fonts;
} Drw;
Drw *drw_create(Display *dpy, int screen, Window win, unsigned int w, unsigned int h);
void drw_resize(Drw *drw, unsigned int w, unsigned int h);
void drw_free(Drw *drw);
Fnt *drw_fontset_create(Drw *drw, const char *fonts[], size_t fontcount);
void drw_fontset_free(Fnt *set);
unsigned int drw_fontset_getwidth(Drw *drw, const char *text);
unsigned int drw_fontset_getwidth_clamp(Drw *drw, const char *text, unsigned int n);
void drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned int *w, unsigned int *h);
void drw_clr_create(Drw *drw, Clr *dest, const char *clrname);
Clr *drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount);
Cur *drw_cur_create(Drw *drw, int shape);
void drw_cur_free(Drw *drw, Cur *cursor);
void drw_setfontset(Drw *drw, Fnt *set);
void drw_setscheme(Drw *drw, Clr *scm);
void drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int invert);
int drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, unsigned int lpad, const char *text, int invert);
void drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h);
#define UTF_INVALID 0xFFFD
#if 0
static int
utf8decode(const char *s_in, long *u, int *err)
{
static const unsigned char lens[] = {
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
2,
2,
2,
2,
3,
3,
4,
};
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);
}
if (cp > 0x10FFFF || (cp >> 11) == 0x1B || cp < overlong[len - 1])
return len;
*err = 0;
*u = cp;
return len;
}
#else
static int utf8decode(const char *s_in, long *u, int *err)
{
const unsigned char *s = (const unsigned char *)s_in;
*u = UTF_INVALID; // Default to replacement character
*err = 1; // Assume error initially
// Handle empty input
if (*s == '\0')
return 0;
// 1-byte ASCII (0xxxxxxx)
if ((s[0] & 0x80) == 0)
{
*u = s[0];
*err = 0;
return 1;
}
// 2-byte sequence (110xxxxx 10xxxxxx)
if ((s[0] & 0xE0) == 0xC0)
{
if (s[1] == '\0' || (s[1] & 0xC0) != 0x80)
return 1; // Invalid second byte
*u = ((s[0] & 0x1F) << 6) | (s[1] & 0x3F);
if (*u < 0x80)
return 1; // Overlong encoding
*err = 0;
return 2;
}
// 3-byte sequence (1110xxxx 10xxxxxx 10xxxxxx) → Covers U+276F (❯)
if ((s[0] & 0xF0) == 0xE0)
{
if (s[1] == '\0' || (s[1] & 0xC0) != 0x80)
return 1;
if (s[2] == '\0' || (s[2] & 0xC0) != 0x80)
return 2;
*u = ((s[0] & 0x0F) << 12) | ((s[1] & 0x3F) << 6) | (s[2] & 0x3F);
if (*u < 0x800)
return 1; // Overlong encoding
if ((*u >= 0xD800) && (*u <= 0xDFFF))
return 3; // Surrogate pair (invalid)
*err = 0;
return 3;
}
// 4-byte sequence (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)
if ((s[0] & 0xF8) == 0xF0)
{
if (s[1] == '\0' || (s[1] & 0xC0) != 0x80)
return 1;
if (s[2] == '\0' || (s[2] & 0xC0) != 0x80)
return 2;
if (s[3] == '\0' || (s[3] & 0xC0) != 0x80)
return 3;
*u = ((s[0] & 0x07) << 18) | ((s[1] & 0x3F) << 12) | ((s[2] & 0x3F) << 6) | (s[3] & 0x3F);
if (*u < 0x10000 || *u > 0x10FFFF)
return 1; // Out of Unicode range
*err = 0;
return 4;
}
// Invalid UTF-8 leading byte
return 1;
}
#endif
Drw *drw_create(Display *dpy, int screen, Window root, unsigned int w, unsigned int h)
{
Drw *drw = ecalloc(1, sizeof(Drw));
drw->dpy = dpy;
drw->screen = screen;
drw->root = root;
drw->w = w;
drw->h = h;
drw->drawable = XCreatePixmap(dpy, root, w, h, DefaultDepth(dpy, screen));
drw->gc = XCreateGC(dpy, root, 0, NULL);
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);
drw->drawable = XCreatePixmap(drw->dpy, drw->root, w, h, DefaultDepth(drw->dpy, drw->screen));
}
void drw_free(Drw *drw)
{
XFreePixmap(drw->dpy, drw->drawable);
XFreeGC(drw->dpy, drw->gc);
drw_fontset_free(drw->fonts);
free(drw);
}
static Fnt *
xfont_create(Drw *drw, const char *fontname, FcPattern *fontpattern)
{
Fnt *font;
XftFont *xfont = NULL;
FcPattern *pattern = NULL;
if (fontname)
{
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.");
}
font = ecalloc(1, sizeof(Fnt));
font->xfont = xfont;
font->pattern = pattern;
font->h = xfont->ascent + xfont->descent;
font->dpy = drw->dpy;
return font;
}
static void
xfont_free(Fnt *font)
{
if (!font)
return;
if (font->pattern)
FcPatternDestroy(font->pattern);
XftFontClose(font->dpy, font->xfont);
free(font);
}
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);
}
void drw_fontset_free(Fnt *font)
{
if (font)
{
drw_fontset_free(font->next);
xfont_free(font);
}
}
void drw_clr_create(Drw *drw, Clr *dest, const char *clrname)
{
if (!drw || !dest || !clrname)
return;
if (!XftColorAllocName(drw->dpy, DefaultVisual(drw->dpy, drw->screen),
DefaultColormap(drw->dpy, drw->screen),
clrname, dest))
die("error, cannot allocate color '%s'", clrname);
}
Clr *drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount)
{
size_t i;
Clr *ret;
if (!drw || !clrnames || clrcount < 2 || !(ret = ecalloc(clrcount, sizeof(XftColor))))
return NULL;
for (i = 0; i < clrcount; i++)
drw_clr_create(drw, &ret[i], clrnames[i]);
return ret;
}
void drw_setfontset(Drw *drw, Fnt *set)
{
if (drw)
drw->fonts = set;
}
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);
}
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;
static unsigned int nomatches[128], ellipsis_width, invalid_width;
static const char invalid[] = "�";
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 (w < lpad)
return x + w;
d = XftDrawCreate(drw->dpy, drw->drawable,
DefaultVisual(drw->dpy, drw->screen),
DefaultColormap(drw->dpy, drw->screen));
x += lpad;
w -= lpad;
}
usedfont = drw->fonts;
if (!ellipsis_width && render)
ellipsis_width = drw_fontset_getwidth(drw, "...");
if (!invalid_width && render)
invalid_width = drw_fontset_getwidth(drw, invalid);
while (1)
{
ew = ellipsis_len = utf8err = utf8charlen = 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)
{
ellipsis_x = x + ew;
ellipsis_w = w - ew;
ellipsis_len = utf8strlen;
}
if (ew + tmpw > w)
{
overflow = 1;
if (!render)
x += tmpw;
else
utf8strlen = ellipsis_len;
}
else if (curfont == usedfont)
{
text += utf8charlen;
utf8strlen += utf8err ? 0 : utf8charlen;
ew += utf8err ? 0 : tmpw;
}
else
{
nextfont = curfont;
}
break;
}
}
if (overflow || !charexists || nextfont || utf8err)
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 (utf8err && (!render || invalid_width < w))
{
if (render)
drw_text(drw, x, y, w, h, 0, invalid, invert);
x += invalid_width;
w -= invalid_width;
}
if (render && overflow)
drw_text(drw, ellipsis_x, y, ellipsis_w, h, 0, "...", invert);
if (!*text || overflow)
{
break;
}
else if (nextfont)
{
charexists = 0;
usedfont = nextfont;
}
else
{
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);
if (nomatches[h0] == utf8codepoint || nomatches[h1] == utf8codepoint)
goto no_match;
fccharset = FcCharSetCreate();
FcCharSetAddChar(fccharset, utf8codepoint);
if (!drw->fonts->pattern)
{
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);
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)
;
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);
}
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);
}
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);
}
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;
}
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);
}
#define INTERSECT(x, y, w, h, r) (MAX(0, MIN((x) + (w), (r).x_org + (r).width) - MAX((x), (r).x_org)) * MAX(0, MIN((y) + (h), (r).y_org + (r).height) - MAX((y), (r).y_org)))
#define TEXTW(X) (drw_fontset_getwidth(drw, (X)) + lrpad)
struct item
{
char *text;
struct item *left, *right;
int out;
};
static char text[BUFSIZ] = "";
static char *embed;
static int bh;
static unsigned int mw, mh; // Changed to unsigned to match other width variables
static unsigned int inputw = 0, promptw; // Changed to unsigned
static int lrpad;
static size_t cursor;
static struct item *items = NULL;
static struct item *matches, *matchend;
static struct item *prev, *curr, *next, *sel;
static int mon = -1, screen;
static Atom clip, utf8;
static Display *dpy;
static Window root, parentwin, win;
static XIC xic;
static Drw *drw;
static Clr *scheme[SchemeLast];
static int (*fstrncmp)(const char *, const char *, size_t) = strncmp;
static char *(*fstrstr)(const char *, const char *) = strstr;
static unsigned int
textw_clamp(const char *str, unsigned int n)
{
unsigned int w = drw_fontset_getwidth_clamp(drw, str, n) + lrpad;
return MIN(w, n);
}
static void
appenditem(struct item *item, struct item **list, struct item **last)
{
if (*last)
(*last)->right = item;
else
*list = item;
item->left = *last;
item->right = NULL;
*last = item;
}
static void
calcoffsets(void)
{
unsigned int i = 0; // Changed to unsigned to match other variables
unsigned int n; // Changed to unsigned
if (lines > 0)
n = lines * (unsigned int)bh; // Explicit cast to resolve signedness
else
n = mw - (promptw + inputw + TEXTW("<") + TEXTW(">"));
for (i = 0, next = curr; next; next = next->right)
{
// Use explicit cast to resolve signedness warning
i += (lines > 0) ? (unsigned int)bh : textw_clamp(next->text, n);
if (i > n)
break;
}
for (i = 0, prev = curr; prev && prev->left; prev = prev->left)
{
// Use explicit cast to resolve signedness warning
i += (lines > 0) ? (unsigned int)bh : textw_clamp(prev->left->text, n);
if (i > n)
break;
}
}
static void
cleanup(void)
{
size_t i;
XUngrabKeyboard(dpy, CurrentTime);
for (i = 0; i < SchemeLast; i++)
free(scheme[i]);
for (i = 0; items && items[i].text; ++i)
free(items[i].text);
free(items);
drw_free(drw);
XSync(dpy, False);
XCloseDisplay(dpy);
}
static char *
cistrstr(const char *h, const char *n)
{
size_t i;
if (!n[0])
return (char *)h;
for (; *h; ++h)
{
for (i = 0; n[i] && tolower((unsigned char)n[i]) ==
tolower((unsigned char)h[i]);
++i)
;
if (n[i] == '\0')
return (char *)h;
}
return NULL;
}
static int
drawitem(struct item *item, int x, int y, int w)
{
if (item == sel)
drw_setscheme(drw, scheme[SchemeSel]);
else if (item->out)
drw_setscheme(drw, scheme[SchemeOut]);
else
drw_setscheme(drw, scheme[SchemeNorm]);
return drw_text(drw, x, y, w, bh, lrpad / 2, item->text, 0);
}
static void
drawmenu(void)
{
unsigned int curpos;
struct item *item;
int x = 0, y = 0;
unsigned int w; // Changed to unsigned to match other width variables
drw_setscheme(drw, scheme[SchemeNorm]);
drw_rect(drw, 0, 0, mw, mh, 1, 1);
if (prompt && *prompt)
{
drw_setscheme(drw, scheme[SchemeSel]);
x = drw_text(drw, x, 0, promptw, bh, lrpad / 2, prompt, 0);
}
w = (lines > 0 || !matches) ? mw - (unsigned int)x : inputw;
drw_setscheme(drw, scheme[SchemeNorm]);
drw_text(drw, x, 0, w, bh, lrpad / 2, text, 0);
curpos = TEXTW(text) - TEXTW(&text[cursor]);
// Cast to unsigned to resolve signedness warning
if ((curpos += (unsigned int)(lrpad / 2 - 1)) < w)
{
drw_setscheme(drw, scheme[SchemeNorm]);
drw_rect(drw, x + (int)curpos, 2, 2, bh - 4, 1, 0);
}
if (lines > 0)
{
for (item = curr; item != next; item = item->right)
drawitem(item, x, y += bh, mw - x);
}
else if (matches)
{
x += inputw;
w = TEXTW("<");
if (curr->left)
{
drw_setscheme(drw, scheme[SchemeNorm]);
drw_text(drw, x, 0, w, bh, lrpad / 2, "<", 0);
}
x += w;
for (item = curr; item != next; item = item->right)
x = drawitem(item, x, 0, textw_clamp(item->text, mw - x - TEXTW(">")));
if (next)
{
w = TEXTW(">");
drw_setscheme(drw, scheme[SchemeNorm]);
drw_text(drw, mw - w, 0, w, bh, lrpad / 2, ">", 0);
}
}
drw_map(drw, win, 0, 0, mw, mh);
}
static void
grabfocus(void)
{
struct timespec ts = {.tv_sec = 0, .tv_nsec = 10000000};
Window focuswin;
int i, revertwin;
for (i = 0; i < 100; ++i)
{
XGetInputFocus(dpy, &focuswin, &revertwin);
if (focuswin == win)
return;
XSetInputFocus(dpy, win, RevertToParent, CurrentTime);
nanosleep(&ts, NULL);
}
die("cannot grab focus");
}
static void
grabkeyboard(void)
{
struct timespec ts = {.tv_sec = 0, .tv_nsec = 1000000};
int i;
if (embed)
return;
for (i = 0; i < 1000; i++)
{
if (XGrabKeyboard(dpy, DefaultRootWindow(dpy), True, GrabModeAsync,
GrabModeAsync, CurrentTime) == GrabSuccess)
return;
nanosleep(&ts, NULL);
}
die("cannot grab keyboard");
}
static void
match(void)
{
static char **tokv = NULL;
static int tokn = 0;
char buf[sizeof text], *s;
int i, tokc = 0;
size_t len, textsize;
struct item *item, *lprefix, *lsubstr, *prefixend, *substrend;
strcpy(buf, text);
for (s = strtok(buf, " "); s; tokv[tokc - 1] = s, s = strtok(NULL, " "))
if (++tokc > tokn && !(tokv = realloc(tokv, ++tokn * sizeof *tokv)))
die("cannot realloc %zu bytes:", tokn * sizeof *tokv);
len = tokc ? strlen(tokv[0]) : 0;
matches = lprefix = lsubstr = matchend = prefixend = substrend = NULL;
textsize = strlen(text) + 1;
for (item = items; item && item->text; item++)
{
for (i = 0; i < tokc; i++)
if (!fstrstr(item->text, tokv[i]))
break;
if (i != tokc)
continue;
if (!tokc || !fstrncmp(text, item->text, textsize))
appenditem(item, &matches, &matchend);
else if (!fstrncmp(tokv[0], item->text, len))
appenditem(item, &lprefix, &prefixend);
else
appenditem(item, &lsubstr, &substrend);
}
if (lprefix)
{
if (matches)
{
matchend->right = lprefix;
lprefix->left = matchend;
}
else
matches = lprefix;
matchend = prefixend;
}
if (lsubstr)
{
if (matches)
{
matchend->right = lsubstr;
lsubstr->left = matchend;
}
else
matches = lsubstr;
matchend = substrend;
}
curr = sel = matches;
calcoffsets();
}
static void
insert(const char *str, ssize_t n)
{
if (strlen(text) + n > sizeof text - 1)
return;
memmove(&text[cursor + n], &text[cursor], sizeof text - cursor - MAX(n, 0));
if (n > 0)
memcpy(&text[cursor], str, n);
cursor += n;
match();
}
static size_t
nextrune(int inc)
{
ssize_t n;
for (n = cursor + inc; n + inc >= 0 && (text[n] & 0xc0) == 0x80; n += inc)
;
return n;
}
static void
movewordedge(int dir)
{
if (dir < 0)
{
while (cursor > 0 && strchr(worddelimiters, text[nextrune(-1)]))
cursor = nextrune(-1);
while (cursor > 0 && !strchr(worddelimiters, text[nextrune(-1)]))
cursor = nextrune(-1);
}
else
{
while (text[cursor] && strchr(worddelimiters, text[cursor]))
cursor = nextrune(+1);
while (text[cursor] && !strchr(worddelimiters, text[cursor]))
cursor = nextrune(+1);
}
}
static void
keypress(XKeyEvent *ev)
{
char buf[64];
int len;
KeySym ksym = NoSymbol;
Status status;
len = XmbLookupString(xic, ev, buf, sizeof buf, &ksym, &status);
switch (status)
{
default:
return;
case XLookupChars:
goto insert;
case XLookupKeySym:
case XLookupBoth:
break;
}
if (ev->state & ControlMask)
{
switch (ksym)
{
case XK_a:
ksym = XK_Home;
break;
case XK_b:
ksym = XK_Left;
break;
case XK_c:
ksym = XK_Escape;
break;
case XK_d:
ksym = XK_Delete;
break;
case XK_e:
ksym = XK_End;
break;
case XK_f:
ksym = XK_Right;
break;
case XK_g:
ksym = XK_Escape;
break;
case XK_h:
ksym = XK_BackSpace;
break;
case XK_i:
ksym = XK_Tab;
break;
case XK_j:
case XK_J:
case XK_m:
case XK_M:
ksym = XK_Return;
ev->state &= ~ControlMask;
break;
case XK_n:
ksym = XK_Down;
break;
case XK_p:
ksym = XK_Up;
break;
case XK_k:
text[cursor] = '\0';
match();
break;
case XK_u:
insert(NULL, 0 - cursor);
break;
case XK_w:
while (cursor > 0 && strchr(worddelimiters, text[nextrune(-1)]))
insert(NULL, nextrune(-1) - cursor);
while (cursor > 0 && !strchr(worddelimiters, text[nextrune(-1)]))
insert(NULL, nextrune(-1) - cursor);
break;
case XK_y:
case XK_Y:
XConvertSelection(dpy, (ev->state & ShiftMask) ? clip : XA_PRIMARY,
utf8, utf8, win, CurrentTime);
return;
case XK_Left:
case XK_KP_Left:
movewordedge(-1);
goto draw;
case XK_Right:
case XK_KP_Right:
movewordedge(+1);
goto draw;
case XK_Return:
case XK_KP_Enter:
break;
case XK_bracketleft:
cleanup();
exit(1);
default:
return;
}
}
else if (ev->state & Mod1Mask)
{
switch (ksym)
{
case XK_b:
movewordedge(-1);
goto draw;
case XK_f:
movewordedge(+1);
goto draw;
case XK_g:
ksym = XK_Home;
break;
case XK_G:
ksym = XK_End;
break;
case XK_h:
ksym = XK_Up;
break;
case XK_j:
ksym = XK_Next;
break;
case XK_k:
ksym = XK_Prior;
break;
case XK_l:
ksym = XK_Down;
break;
default:
return;
}
}
switch (ksym)
{
default:
insert:
if (!iscntrl((unsigned char)*buf))
insert(buf, len);
break;
case XK_Delete:
case XK_KP_Delete:
if (text[cursor] == '\0')
return;
cursor = nextrune(+1);
/* Fall through */
__attribute__((fallthrough)); // Explicit fallthrough annotation
case XK_BackSpace:
if (cursor == 0)
return;
insert(NULL, nextrune(-1) - cursor);
break;
case XK_End:
case XK_KP_End:
if (text[cursor] != '\0')
{
cursor = strlen(text);
break;
}
if (next)
{
curr = matchend;
calcoffsets();
curr = prev;
calcoffsets();
while (next && (curr = curr->right))
calcoffsets();
}
sel = matchend;
break;
case XK_Escape:
cleanup();
exit(1);
case XK_Home:
case XK_KP_Home:
if (sel == matches)
{
cursor = 0;
break;
}
sel = curr = matches;
calcoffsets();
break;
case XK_Left:
case XK_KP_Left:
if (cursor > 0 && (!sel || !sel->left || lines > 0))
{
cursor = nextrune(-1);
break;
}
if (lines > 0)
return;
__attribute__((fallthrough));
case XK_Up:
case XK_KP_Up:
if (sel && sel->left && (sel = sel->left)->right == curr)
{
curr = prev;
calcoffsets();
}
break;
case XK_Next:
case XK_KP_Next:
if (!next)
return;
sel = curr = next;
calcoffsets();
break;
case XK_Prior:
case XK_KP_Prior:
if (!prev)
return;
sel = curr = prev;
calcoffsets();
break;
case XK_Return:
case XK_KP_Enter:
puts((sel && !(ev->state & ShiftMask)) ? sel->text : text);
if (!(ev->state & ControlMask))
{
cleanup();
exit(0);
}
if (sel)
sel->out = 1;
break;
case XK_Right:
case XK_KP_Right:
if (text[cursor] != '\0')
{
cursor = nextrune(+1);
break;
}
if (lines > 0)
return;
__attribute__((fallthrough));
case XK_Down:
case XK_KP_Down:
if (sel && sel->right && (sel = sel->right) == next)
{
curr = next;
calcoffsets();
}
break;
case XK_Tab:
if (!sel)
return;
cursor = strnlen(sel->text, sizeof text - 1);
memcpy(text, sel->text, cursor);
text[cursor] = '\0';
match();
break;
}
draw:
drawmenu();
}
static void
paste(void)
{
char *p, *q;
int di;
unsigned long dl;
Atom da;
if (XGetWindowProperty(dpy, win, utf8, 0, (sizeof text / 4) + 1, False,
utf8, &da, &di, &dl, &dl, (unsigned char **)&p) == Success &&
p)
{
insert(p, (q = strchr(p, '\n')) ? q - p : (ssize_t)strlen(p));
XFree(p);
}
drawmenu();
}
static void
readstdin(void)
{
char *line = NULL;
size_t i, itemsiz = 0, linesiz = 0;
ssize_t len;
for (i = 0; (len = getline(&line, &linesiz, stdin)) != -1; i++)
{
if (i + 1 >= itemsiz)
{
itemsiz += 256;
if (!(items = realloc(items, itemsiz * sizeof(*items))))
die("cannot realloc %zu bytes:", itemsiz * sizeof(*items));
}
if (line[len - 1] == '\n')
line[len - 1] = '\0';
if (!(items[i].text = strdup(line)))
die("strdup:");
items[i].out = 0;
}
free(line);
if (items)
items[i].text = NULL;
lines = MIN(lines, i);
}
static void
run(void)
{
XEvent ev;
while (!XNextEvent(dpy, &ev))
{
if (XFilterEvent(&ev, win))
continue;
switch (ev.type)
{
case DestroyNotify:
if (ev.xdestroywindow.window != win)
break;
cleanup();
exit(1);
case Expose:
if (ev.xexpose.count == 0)
drw_map(drw, win, 0, 0, mw, mh);
break;
case FocusIn:
if (ev.xfocus.window != win)
grabfocus();
break;
case KeyPress:
keypress(&ev.xkey);
break;
case SelectionNotify:
if (ev.xselection.property == utf8)
paste();
break;
case VisibilityNotify:
if (ev.xvisibility.state != VisibilityUnobscured)
XRaiseWindow(dpy, win);
break;
case ButtonPress:
{
XButtonEvent *bev = &ev.xbutton;
if (bev->button == 4)
{
if (sel && sel->left && (sel = sel->left)->right == curr)
{
curr = prev;
calcoffsets();
}
drawmenu();
}
else if (bev->button == 5)
{
if (sel && sel->right && (sel = sel->right) == next)
{
curr = next;
calcoffsets();
}
drawmenu();
}
else if (bev->button == 1)
{
if (sel)
{
puts(sel->text);
cleanup();
exit(0);
}
}
}
break;
}
}
}
static void
setup(void)
{
int x, y, i, j;
unsigned int du;
XSetWindowAttributes swa;
XIM xim;
Window w, dw, *dws;
XWindowAttributes wa;
XClassHint ch = {"dmenu", "dmenu"};
#ifdef XINERAMA
XineramaScreenInfo *info;
Window pw;
int a, di, n, area = 0;
#endif
for (j = 0; j < SchemeLast; j++)
scheme[j] = drw_scm_create(drw, colors[j], 2);
clip = XInternAtom(dpy, "CLIPBOARD", False);
utf8 = XInternAtom(dpy, "UTF8_STRING", False);
bh = drw->fonts->h + 2;
lines = MAX(lines, 0);
mh = (lines + 1) * (unsigned int)bh;
if (mh > 4096)
{
die("window height too large (reduce font size or lines)");
}
#ifdef XINERAMA
i = 0;
if (parentwin == root && (info = XineramaQueryScreens(dpy, &n)))
{
XGetInputFocus(dpy, &w, &di);
if (mon >= 0 && mon < n)
i = mon;
else if (w != root && w != PointerRoot && w != None)
{
do
{
if (XQueryTree(dpy, (pw = w), &dw, &w, &dws, &du) && dws)
XFree(dws);
} while (w != root && w != pw);
if (XGetWindowAttributes(dpy, pw, &wa))
for (j = 0; j < n; j++)
if ((a = INTERSECT(wa.x, wa.y, wa.width, wa.height, info[j])) > area)
{
area = a;
i = j;
}
}
if (mon < 0 && !area && XQueryPointer(dpy, root, &dw, &dw, &x, &y, &di, &di, &du))
for (i = 0; i < n; i++)
if (INTERSECT(x, y, 1, 1, info[i]) != 0)
break;
x = info[i].x_org;
y = info[i].y_org + (topbar ? 0 : info[i].height - (int)mh); // Explicit cast
mw = info[i].width;
XFree(info);
}
else
#endif
{
if (!XGetWindowAttributes(dpy, parentwin, &wa))
die("could not get embedding window attributes: 0x%lx",
parentwin);
x = 0;
y = topbar ? 0 : wa.height - (int)mh; // Explicit cast
mw = wa.width;
}
promptw = (prompt && *prompt) ? TEXTW(prompt) - lrpad / 4 : 0;
inputw = mw / 3;
match();
swa.override_redirect = True;
swa.background_pixel = scheme[SchemeNorm][ColBg].pixel;
swa.event_mask = ExposureMask | KeyPressMask | VisibilityChangeMask | ButtonPressMask;
win = XCreateWindow(dpy, root, x, y, mw, mh, 0,
CopyFromParent, CopyFromParent, CopyFromParent,
CWOverrideRedirect | CWBackPixel | CWEventMask, &swa);
XSetClassHint(dpy, win, &ch);
if ((xim = XOpenIM(dpy, NULL, NULL, NULL)) == NULL)
die("XOpenIM failed: could not open input device");
xic = XCreateIC(xim, XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
XNClientWindow, win, XNFocusWindow, win, NULL);
XMapRaised(dpy, win);
if (embed)
{
XReparentWindow(dpy, win, parentwin, x, y);
XSelectInput(dpy, parentwin, FocusChangeMask | SubstructureNotifyMask);
if (XQueryTree(dpy, parentwin, &dw, &w, &dws, &du) && dws)
{
// Use explicit cast to resolve signedness warning
for (i = 0; (unsigned int)i < du && dws[i] != win; ++i)
XSelectInput(dpy, dws[i], FocusChangeMask);
XFree(dws);
}
grabfocus();
}
drw_resize(drw, mw, mh);
drawmenu();
}
static void
usage(void)
{
die("usage: dmenu [-bfiv] [-l lines] [-p prompt] [-fn font] [-m monitor]\n"
" [-nb color] [-nf color] [-sb color] [-sf color] [-w windowid]");
}
int main(int argc, char *argv[])
{
XWindowAttributes wa;
int i, fast = 0;
for (i = 1; i < argc; i++)
if (!strcmp(argv[i], "-v"))
{
puts("dmenu-1.0");
exit(0);
}
else if (!strcmp(argv[i], "-b"))
topbar = 0;
else if (!strcmp(argv[i], "-f"))
fast = 1;
else if (!strcmp(argv[i], "-i"))
{
fstrncmp = strncasecmp;
fstrstr = cistrstr;
}
else if (i + 1 == argc)
usage();
else if (!strcmp(argv[i], "-l"))
lines = atoi(argv[++i]);
else if (!strcmp(argv[i], "-m"))
mon = atoi(argv[++i]);
else if (!strcmp(argv[i], "-p"))
prompt = argv[++i];
else if (!strcmp(argv[i], "-fn"))
fonts[0] = argv[++i];
else if (!strcmp(argv[i], "-nb"))
colors[SchemeNorm][ColBg] = argv[++i];
else if (!strcmp(argv[i], "-nf"))
colors[SchemeNorm][ColFg] = argv[++i];
else if (!strcmp(argv[i], "-sb"))
colors[SchemeSel][ColBg] = argv[++i];
else if (!strcmp(argv[i], "-sf"))
colors[SchemeSel][ColFg] = argv[++i];
else if (!strcmp(argv[i], "-w"))
embed = argv[++i];
else
usage();
if (!setlocale(LC_CTYPE, "") || !XSupportsLocale())
fputs("warning: no locale support\n", stderr);
if (!(dpy = XOpenDisplay(NULL)))
die("cannot open display");
screen = DefaultScreen(dpy);
root = RootWindow(dpy, screen);
if (!embed || !(parentwin = strtol(embed, NULL, 0)))
parentwin = root;
if (!XGetWindowAttributes(dpy, parentwin, &wa))
die("could not get embedding window attributes: 0x%lx",
parentwin);
drw = drw_create(dpy, screen, root, wa.width, wa.height);
if (!drw_fontset_create(drw, fonts, LENGTH(fonts)))
die("no fonts could be loaded.");
if (!drw->fonts || !drw->fonts->xfont)
{
die("failed to load valid font (check font name/size)");
}
lrpad = drw->fonts->h; // 确保drw->fonts非空再访问
#ifdef __OpenBSD__
if (pledge("stdio rpath", NULL) == -1)
die("pledge");
#endif
if (fast && !isatty(0))
{
grabkeyboard();
readstdin();
}
else
{
readstdin();
grabkeyboard();
}
setup();
run();
return 1;
}