tfinished libsl/drw integration - dwm - [fork] customized build of dwm, the dyn… | |
git clone git://src.adamsgaard.dk/dwm | |
Log | |
Files | |
Refs | |
README | |
LICENSE | |
--- | |
commit 5364697914fd4272fc1a6494b4fc522d2935427a | |
parent 7edc59631193813cf4d64030f8864de36b193cfc | |
Author: Anselm R Garbe <[email protected]> | |
Date: Sun, 16 Jun 2013 15:20:29 +0200 | |
finished libsl/drw integration | |
Diffstat: | |
M drw.c | 150 ++++++++++++++++++-----------… | |
M drw.h | 46 ++++++++++++++++++-----------… | |
M dwm.c | 253 +++++++++--------------------… | |
3 files changed, 185 insertions(+), 264 deletions(-) | |
--- | |
diff --git a/drw.c b/drw.c | |
t@@ -8,15 +8,17 @@ | |
#include "util.h" | |
Drw * | |
-drw_create(Display *dpy, int screen, Window win, unsigned int w, unsigned int … | |
+drw_create(Display *dpy, int screen, Window root, unsigned int w, unsigned int… | |
Drw *drw = (Drw *)calloc(1, sizeof(Drw)); | |
+ if(!drw) | |
+ return NULL; | |
drw->dpy = dpy; | |
drw->screen = screen; | |
- drw->win = win; | |
+ drw->root = root; | |
drw->w = w; | |
drw->h = h; | |
- drw->drwable = XCreatePixmap(dpy, win, w, h, DefaultDepth(dpy, screen)… | |
- drw->gc = XCreateGC(dpy, win, 0, NULL); | |
+ drw->drawable = XCreatePixmap(dpy, root, w, h, DefaultDepth(dpy, scree… | |
+ drw->gc = XCreateGC(dpy, root, 0, NULL); | |
XSetLineAttributes(dpy, drw->gc, 1, LineSolid, CapButt, JoinMiter); | |
return drw; | |
} | |
t@@ -27,27 +29,28 @@ drw_resize(Drw *drw, unsigned int w, unsigned int h) { | |
return; | |
drw->w = w; | |
drw->h = h; | |
- XFreePixmap(drw->dpy, drw->drwable); | |
- drw->drwable = XCreatePixmap(drw->dpy, drw->win, w, h, DefaultDepth(dr… | |
+ if(drw->drawable != 0) | |
+ XFreePixmap(drw->dpy, drw->drawable); | |
+ drw->drawable = XCreatePixmap(drw->dpy, drw->root, w, h, DefaultDepth(… | |
} | |
void | |
drw_free(Drw *drw) { | |
- XFreePixmap(drw->dpy, drw->drwable); | |
+ XFreePixmap(drw->dpy, drw->drawable); | |
XFreeGC(drw->dpy, drw->gc); | |
free(drw); | |
} | |
Fnt * | |
-drw_font_create(Drw *drw, const char *fontname) { | |
+drw_font_create(Display *dpy, const char *fontname) { | |
Fnt *font; | |
char *def, **missing; | |
int n; | |
- if(!drw) | |
- return NULL; | |
font = (Fnt *)calloc(1, sizeof(Fnt)); | |
- font->set = XCreateFontSet(drw->dpy, fontname, &missing, &n, &def); | |
+ if(!font) | |
+ return NULL; | |
+ font->set = XCreateFontSet(dpy, fontname, &missing, &n, &def); | |
if(missing) { | |
while(n--) | |
fprintf(stderr, "drw: missing fontset: %s\n", missing[… | |
t@@ -65,8 +68,8 @@ drw_font_create(Drw *drw, const char *fontname) { | |
} | |
} | |
else { | |
- if(!(font->xfont = XLoadQueryFont(drw->dpy, fontname)) | |
- && !(font->xfont = XLoadQueryFont(drw->dpy, "fixed"))) | |
+ if(!(font->xfont = XLoadQueryFont(dpy, fontname)) | |
+ && !(font->xfont = XLoadQueryFont(dpy, "fixed"))) | |
die("error, cannot load font: '%s'\n", fontname); | |
font->ascent = font->xfont->ascent; | |
font->descent = font->xfont->descent; | |
t@@ -76,22 +79,28 @@ drw_font_create(Drw *drw, const char *fontname) { | |
} | |
void | |
-drw_font_free(Drw *drw, Fnt *font) { | |
- if(!drw || !font) | |
+drw_font_free(Display *dpy, Fnt *font) { | |
+ if(!font) | |
return; | |
if(font->set) | |
- XFreeFontSet(drw->dpy, font->set); | |
+ XFreeFontSet(dpy, font->set); | |
else | |
- XFreeFont(drw->dpy, font->xfont); | |
+ XFreeFont(dpy, font->xfont); | |
free(font); | |
} | |
Clr * | |
drw_clr_create(Drw *drw, const char *clrname) { | |
- Clr *clr = (Clr *)calloc(1, sizeof(Clr)); | |
- Colormap cmap = DefaultColormap(drw->dpy, drw->screen); | |
+ Clr *clr; | |
+ Colormap cmap; | |
XColor color; | |
+ if(!drw) | |
+ return NULL; | |
+ clr = (Clr *)calloc(1, sizeof(Clr)); | |
+ if(!clr) | |
+ return NULL; | |
+ cmap = DefaultColormap(drw->dpy, drw->screen); | |
if(!XAllocNamedColor(drw->dpy, cmap, clrname, &color, &color)) | |
die("error, cannot allocate color '%s'\n", clrname); | |
clr->rgb = color.pixel; | |
t@@ -99,7 +108,7 @@ drw_clr_create(Drw *drw, const char *clrname) { | |
} | |
void | |
-drw_clr_free(Drw *drw, Clr *clr) { | |
+drw_clr_free(Clr *clr) { | |
if(!clr) | |
return; | |
free(clr); | |
t@@ -107,96 +116,113 @@ drw_clr_free(Drw *drw, Clr *clr) { | |
void | |
drw_setfont(Drw *drw, Fnt *font) { | |
- if(!drw) | |
- return; | |
- drw->font = font; | |
+ if(drw) | |
+ drw->font = font; | |
} | |
void | |
-drw_setfg(Drw *drw, Clr *clr) { | |
- if(!drw) | |
+drw_settheme(Drw *drw, Theme *theme) { | |
+ if(!drw || !theme) | |
return; | |
- drw->fg = clr; | |
+ drw->theme = theme; | |
} | |
void | |
-drw_setbg(Drw *drw, Clr *clr) { | |
- if(!drw) | |
- return; | |
- drw->bg = clr; | |
-} | |
- | |
-void | |
-drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, Bool filled, … | |
+drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, i… | |
int dx; | |
- if(!drw || !drw->font || !drw->fg || !drw->bg) | |
+ if(!drw || !drw->font || !drw->theme) | |
return; | |
- XSetForeground(drw->dpy, drw->gc, invert ? drw->bg->rgb : drw->fg->rgb… | |
+ XSetForeground(drw->dpy, drw->gc, invert ? drw->theme->bg->rgb : drw->… | |
dx = (drw->font->ascent + drw->font->descent + 2) / 4; | |
if(filled) | |
- XFillRectangle(drw->dpy, drw->drwable, drw->gc, x+1, y+1, dx+1… | |
+ XFillRectangle(drw->dpy, drw->drawable, drw->gc, x+1, y+1, dx+… | |
else if(empty) | |
- XDrawRectangle(drw->dpy, drw->drwable, drw->gc, x+1, y+1, dx, … | |
+ XDrawRectangle(drw->dpy, drw->drawable, drw->gc, x+1, y+1, dx,… | |
} | |
void | |
-drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, const char *t… | |
+drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, const char *t… | |
char buf[256]; | |
- int i, tx, ty, len, olen; | |
+ int i, tx, ty, th, len, olen; | |
Extnts tex; | |
- if(!drw || !drw->fg || !drw->bg) | |
+ if(!drw || !drw->theme) | |
return; | |
- XSetForeground(drw->dpy, drw->gc, invert ? drw->fg->rgb : drw->bg->rgb… | |
- XFillRectangle(drw->dpy, drw->drwable, drw->gc, x, y, w, h); | |
+ XSetForeground(drw->dpy, drw->gc, invert ? drw->theme->fg->rgb : drw->… | |
+ XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h); | |
if(!text || !drw->font) | |
return; | |
olen = strlen(text); | |
- drw_getexts(drw, text, olen, &tex); | |
- ty = y + (h / 2) - tex.yOff; | |
- tx = x + tex.xOff; | |
+ drw_font_getexts(drw->font, text, olen, &tex); | |
+ th = drw->font->ascent + drw->font->descent; | |
+ ty = y + (h / 2) - (th / 2) + drw->font->ascent; | |
+ tx = x + (h / 2); | |
/* shorten text if necessary */ | |
for(len = MIN(olen, sizeof buf); len && tex.w > w - tex.h; len--) | |
- drw_getexts(drw, text, len, &tex); | |
+ drw_font_getexts(drw->font, text, len, &tex); | |
if(!len) | |
return; | |
memcpy(buf, text, len); | |
if(len < olen) | |
for(i = len; i && i > len - 3; buf[--i] = '.'); | |
- XSetForeground(drw->dpy, drw->gc, invert ? drw->bg->rgb : drw->fg->rgb… | |
+ XSetForeground(drw->dpy, drw->gc, invert ? drw->theme->bg->rgb : drw->… | |
if(drw->font->set) | |
- XmbDrawString(drw->dpy, drw->drwable, drw->font->set, drw->gc,… | |
+ XmbDrawString(drw->dpy, drw->drawable, drw->font->set, drw->gc… | |
else | |
- XDrawString(drw->dpy, drw->drwable, drw->gc, tx, ty, buf, len); | |
+ XDrawString(drw->dpy, drw->drawable, drw->gc, tx, ty, buf, len… | |
} | |
void | |
-drw_map(Drw *drw, int x, int y, unsigned int w, unsigned int h) { | |
+drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h) { | |
if(!drw) | |
return; | |
- XCopyArea(drw->dpy, drw->drwable, drw->win, drw->gc, x, y, w, h, x, y); | |
+ XCopyArea(drw->dpy, drw->drawable, win, drw->gc, x, y, w, h, x, y); | |
XSync(drw->dpy, False); | |
} | |
void | |
-drw_getexts(Drw *drw, const char *text, unsigned int len, Extnts *tex) { | |
+drw_font_getexts(Fnt *font, const char *text, unsigned int len, Extnts *tex) { | |
XRectangle r; | |
- if(!drw || !drw->font || !text) | |
+ if(!font || !text) | |
return; | |
- if(drw->font->set) { | |
- XmbTextExtents(drw->font->set, text, len, NULL, &r); | |
- tex->xOff = r.x; | |
- tex->yOff = r.y; | |
+ if(font->set) { | |
+ XmbTextExtents(font->set, text, len, NULL, &r); | |
tex->w = r.width; | |
tex->h = r.height; | |
} | |
else { | |
- tex->h = drw->font->ascent + drw->font->descent; | |
- tex->w = XTextWidth(drw->font->xfont, text, len); | |
- tex->xOff = tex->h / 2; | |
- tex->yOff = (tex->h / 2) + drw->font->ascent; | |
+ tex->h = font->ascent + font->descent; | |
+ tex->w = XTextWidth(font->xfont, text, len); | |
} | |
} | |
+ | |
+unsigned int | |
+drw_font_getexts_width(Fnt *font, const char *text, unsigned int len) { | |
+ Extnts tex; | |
+ | |
+ if(!font) | |
+ return -1; | |
+ drw_font_getexts(font, text, len, &tex); | |
+ return tex.w; | |
+} | |
+ | |
+Cur * | |
+drw_cur_create(Drw *drw, int shape) { | |
+ Cur *cur = (Cur *)calloc(1, sizeof(Cur)); | |
+ | |
+ if(!drw || !cur) | |
+ return NULL; | |
+ cur->cursor = XCreateFontCursor(drw->dpy, shape); | |
+ return cur; | |
+} | |
+ | |
+void | |
+drw_cur_free(Drw *drw, Cur *cursor) { | |
+ if(!drw || !cursor) | |
+ return; | |
+ XFreeCursor(drw->dpy, cursor->cursor); | |
+ free(cursor); | |
+} | |
diff --git a/drw.h b/drw.h | |
t@@ -5,6 +5,10 @@ typedef struct { | |
} Clr; | |
typedef struct { | |
+ Cursor cursor; | |
+} Cur; | |
+ | |
+typedef struct { | |
int ascent; | |
int descent; | |
unsigned int h; | |
t@@ -13,22 +17,25 @@ typedef struct { | |
} Fnt; | |
typedef struct { | |
+ Clr *fg; | |
+ Clr *bg; | |
+ Clr *border; | |
+} Theme; | |
+ | |
+typedef struct { | |
unsigned int w, h; | |
Display *dpy; | |
int screen; | |
- Window win; | |
- Drawable drwable; | |
+ Window root; | |
+ Drawable drawable; | |
GC gc; | |
- Clr *fg; | |
- Clr *bg; | |
+ Theme *theme; | |
Fnt *font; | |
} Drw; | |
typedef struct { | |
unsigned int w; | |
unsigned int h; | |
- int xOff; | |
- int yOff; | |
} Extnts; | |
/* Drawable abstraction */ | |
t@@ -37,25 +44,26 @@ void drw_resize(Drw *drw, unsigned int w, unsigned int h); | |
void drw_free(Drw *drw); | |
/* Fnt abstraction */ | |
-Fnt *drw_font_create(Drw *drw, const char *fontname); | |
-void drw_font_free(Drw *drw, Fnt *font); | |
+Fnt *drw_font_create(Display *dpy, const char *fontname); | |
+void drw_font_free(Display *dpy, Fnt *font); | |
+void drw_font_getexts(Fnt *font, const char *text, unsigned int len, Extnts *e… | |
+unsigned int drw_font_getexts_width(Fnt *font, const char *text, unsigned int … | |
-/* Clrour abstraction */ | |
+/* Colour abstraction */ | |
Clr *drw_clr_create(Drw *drw, const char *clrname); | |
-void drw_clr_free(Drw *drw, Clr *clr); | |
+void drw_clr_free(Clr *clr); | |
+ | |
+/* Cursor abstraction */ | |
+Cur *drw_cur_create(Drw *drw, int shape); | |
+void drw_cur_free(Drw *drw, Cur *cursor); | |
/* Drawing context manipulation */ | |
void drw_setfont(Drw *drw, Fnt *font); | |
-void drw_setfg(Drw *drw, Clr *clr); | |
-void drw_setbg(Drw *drw, Clr *clr); | |
+void drw_settheme(Drw *drw, Theme *theme); | |
/* Drawing functions */ | |
-void drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, Bool fil… | |
-void drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, const ch… | |
+void drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int fill… | |
+void drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, const ch… | |
/* Map functions */ | |
-void drw_map(Drw *drw, int x, int y, unsigned int w, unsigned int h); | |
- | |
-/* Text functions */ | |
-void drw_getexts(Drw *drw, const char *text, unsigned int len, Extnts *extnts); | |
- | |
+void drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int … | |
diff --git a/dwm.c b/dwm.c | |
t@@ -54,7 +54,7 @@ | |
#define WIDTH(X) ((X)->w + 2 * (X)->bw) | |
#define HEIGHT(X) ((X)->h + 2 * (X)->bw) | |
#define TAGMASK ((1 << LENGTH(tags)) - 1) | |
-#define TEXTW(X) (textnw(X, strlen(X)) + dc.font.height) | |
+#define TEXTW(X) (drw_font_getexts_width(drw->font, X, strlen(X… | |
/* enums */ | |
enum { CurNormal, CurResize, CurMove, CurLast }; /* cursor */ | |
t@@ -99,21 +99,6 @@ struct Client { | |
}; | |
typedef struct { | |
- int x, y, w, h; | |
- unsigned long norm[ColLast]; | |
- unsigned long sel[ColLast]; | |
- Drawable drawable; | |
- GC gc; | |
- struct { | |
- int ascent; | |
- int descent; | |
- int height; | |
- XFontSet set; | |
- XFontStruct *xfont; | |
- } font; | |
-} DC; /* draw context */ | |
- | |
-typedef struct { | |
unsigned int mod; | |
KeySym keysym; | |
void (*func)(const Arg *); | |
t@@ -178,22 +163,18 @@ static void detachstack(Client *c); | |
static Monitor *dirtomon(int dir); | |
static void drawbar(Monitor *m); | |
static void drawbars(void); | |
-static void drawsquare(Bool filled, Bool empty, Bool invert, unsigned long col… | |
-static void drawtext(const char *text, unsigned long col[ColLast], Bool invert… | |
static void enternotify(XEvent *e); | |
static void expose(XEvent *e); | |
static void focus(Client *c); | |
static void focusin(XEvent *e); | |
static void focusmon(const Arg *arg); | |
static void focusstack(const Arg *arg); | |
-static unsigned long getcolor(const char *colstr); | |
static Bool getrootptr(int *x, int *y); | |
static long getstate(Window w); | |
static Bool gettextprop(Window w, Atom atom, char *text, unsigned int size); | |
static void grabbuttons(Client *c, Bool focused); | |
static void grabkeys(void); | |
static void incnmaster(const Arg *arg); | |
-static void initfont(const char *fontstr); | |
static void keypress(XEvent *e); | |
static void killclient(const Arg *arg); | |
static void manage(Window w, XWindowAttributes *wa); | |
t@@ -226,7 +207,6 @@ static void sigchld(int unused); | |
static void spawn(const Arg *arg); | |
static void tag(const Arg *arg); | |
static void tagmon(const Arg *arg); | |
-static int textnw(const char *text, unsigned int len); | |
static void tile(Monitor *); | |
static void togglebar(const Arg *arg); | |
static void togglefloating(const Arg *arg); | |
t@@ -279,10 +259,13 @@ static void (*handler[LASTEvent]) (XEvent *) = { | |
}; | |
static Atom wmatom[WMLast], netatom[NetLast]; | |
static Bool running = True; | |
-static Cursor cursor[CurLast]; | |
+static Cur *cursor[CurLast]; | |
+static Theme thmnorm[ColLast]; | |
+static Theme thmsel[ColLast]; | |
static Display *dpy; | |
-static DC dc; | |
-static Monitor *mons = NULL, *selmon = NULL; | |
+static Drw *drw; | |
+static Fnt *fnt; | |
+static Monitor *mons, *selmon; | |
static Window root; | |
/* configuration, allows nested code to access above variables */ | |
t@@ -486,18 +469,20 @@ cleanup(void) { | |
for(m = mons; m; m = m->next) | |
while(m->stack) | |
unmanage(m->stack, False); | |
- if(dc.font.set) | |
- XFreeFontSet(dpy, dc.font.set); | |
- else | |
- XFreeFont(dpy, dc.font.xfont); | |
XUngrabKey(dpy, AnyKey, AnyModifier, root); | |
- XFreePixmap(dpy, dc.drawable); | |
- XFreeGC(dpy, dc.gc); | |
- XFreeCursor(dpy, cursor[CurNormal]); | |
- XFreeCursor(dpy, cursor[CurResize]); | |
- XFreeCursor(dpy, cursor[CurMove]); | |
while(mons) | |
cleanupmon(mons); | |
+ drw_cur_free(drw, cursor[CurNormal]); | |
+ drw_cur_free(drw, cursor[CurResize]); | |
+ drw_cur_free(drw, cursor[CurMove]); | |
+ drw_font_free(dpy, fnt); | |
+ drw_clr_free(thmnorm->border); | |
+ drw_clr_free(thmnorm->bg); | |
+ drw_clr_free(thmnorm->fg); | |
+ drw_clr_free(thmsel->border); | |
+ drw_clr_free(thmsel->bg); | |
+ drw_clr_free(thmsel->fg); | |
+ drw_free(drw); | |
XSync(dpy, False); | |
XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime); | |
XDeleteProperty(dpy, root, netatom[NetActiveWindow]); | |
t@@ -581,9 +566,7 @@ configurenotify(XEvent *e) { | |
sw = ev->width; | |
sh = ev->height; | |
if(updategeom() || dirty) { | |
- if(dc.drawable != 0) | |
- XFreePixmap(dpy, dc.drawable); | |
- dc.drawable = XCreatePixmap(dpy, root, sw, bh, Default… | |
+ drw_resize(drw, sw, bh); | |
updatebars(); | |
for(m = mons; m; m = m->next) | |
XMoveResizeWindow(dpy, m->barwin, m->wx, m->by… | |
t@@ -710,9 +693,8 @@ dirtomon(int dir) { | |
void | |
drawbar(Monitor *m) { | |
- int x; | |
+ int x, xx, w; | |
unsigned int i, occ = 0, urg = 0; | |
- unsigned long *col; | |
Client *c; | |
for(c = m->clients; c; c = c->next) { | |
t@@ -720,42 +702,44 @@ drawbar(Monitor *m) { | |
if(c->isurgent) | |
urg |= c->tags; | |
} | |
- dc.x = 0; | |
+ x = 0; | |
for(i = 0; i < LENGTH(tags); i++) { | |
- dc.w = TEXTW(tags[i]); | |
- col = m->tagset[m->seltags] & 1 << i ? dc.sel : dc.norm; | |
- drawtext(tags[i], col, urg & 1 << i); | |
- drawsquare(m == selmon && selmon->sel && selmon->sel->tags & 1… | |
- occ & 1 << i, urg & 1 << i, col); | |
- dc.x += dc.w; | |
- } | |
- dc.w = blw = TEXTW(m->ltsymbol); | |
- drawtext(m->ltsymbol, dc.norm, False); | |
- dc.x += dc.w; | |
- x = dc.x; | |
+ w = TEXTW(tags[i]); | |
+ drw_settheme(drw, m->tagset[m->seltags] & 1 << i ? thmsel : th… | |
+ drw_text(drw, x, 0, w, bh, tags[i], urg & 1 << i); | |
+ drw_rect(drw, x, 0, w, bh, m == selmon && selmon->sel && selmo… | |
+ occ & 1 << i, urg & 1 << i); | |
+ x += w; | |
+ } | |
+ w = blw = TEXTW(m->ltsymbol); | |
+ drw_settheme(drw, thmnorm); | |
+ drw_text(drw, x, 0, w, bh, m->ltsymbol, 0); | |
+ x += w; | |
+ xx = x; | |
if(m == selmon) { /* status is only drawn on selected monitor */ | |
- dc.w = TEXTW(stext); | |
- dc.x = m->ww - dc.w; | |
- if(dc.x < x) { | |
- dc.x = x; | |
- dc.w = m->ww - x; | |
+ w = TEXTW(stext); | |
+ x = m->ww - w; | |
+ if(x < xx) { | |
+ x = xx; | |
+ w = m->ww - xx; | |
} | |
- drawtext(stext, dc.norm, False); | |
+ drw_text(drw, x, 0, w, bh, stext, 0); | |
} | |
else | |
- dc.x = m->ww; | |
- if((dc.w = dc.x - x) > bh) { | |
- dc.x = x; | |
+ x = m->ww; | |
+ if((w = x - xx) > bh) { | |
+ x = xx; | |
if(m->sel) { | |
- col = m == selmon ? dc.sel : dc.norm; | |
- drawtext(m->sel->name, col, False); | |
- drawsquare(m->sel->isfixed, m->sel->isfloating, False,… | |
+ drw_settheme(drw, m == selmon ? thmsel : thmnorm); | |
+ drw_text(drw, x, 0, w, bh, m->sel->name, 0); | |
+ drw_rect(drw, x, 0, w, bh, m->sel->isfixed, m->sel->is… | |
+ } | |
+ else { | |
+ drw_settheme(drw, thmnorm); | |
+ drw_text(drw, x, 0, w, bh, NULL, 0); | |
} | |
- else | |
- drawtext(NULL, dc.norm, False); | |
} | |
- XCopyArea(dpy, dc.drawable, m->barwin, dc.gc, 0, 0, m->ww, bh, 0, 0); | |
- XSync(dpy, False); | |
+ drw_map(drw, m->barwin, 0, 0, m->ww, bh); | |
} | |
void | |
t@@ -767,45 +751,6 @@ drawbars(void) { | |
} | |
void | |
-drawsquare(Bool filled, Bool empty, Bool invert, unsigned long col[ColLast]) { | |
- int x; | |
- | |
- XSetForeground(dpy, dc.gc, col[invert ? ColBG : ColFG]); | |
- x = (dc.font.ascent + dc.font.descent + 2) / 4; | |
- if(filled) | |
- XFillRectangle(dpy, dc.drawable, dc.gc, dc.x+1, dc.y+1, x+1, x… | |
- else if(empty) | |
- XDrawRectangle(dpy, dc.drawable, dc.gc, dc.x+1, dc.y+1, x, x); | |
-} | |
- | |
-void | |
-drawtext(const char *text, unsigned long col[ColLast], Bool invert) { | |
- char buf[256]; | |
- int i, x, y, h, len, olen; | |
- | |
- XSetForeground(dpy, dc.gc, col[invert ? ColFG : ColBG]); | |
- XFillRectangle(dpy, dc.drawable, dc.gc, dc.x, dc.y, dc.w, dc.h); | |
- if(!text) | |
- return; | |
- olen = strlen(text); | |
- h = dc.font.ascent + dc.font.descent; | |
- y = dc.y + (dc.h / 2) - (h / 2) + dc.font.ascent; | |
- x = dc.x + (h / 2); | |
- /* shorten text if necessary */ | |
- for(len = MIN(olen, sizeof buf); len && textnw(text, len) > dc.w - h; … | |
- if(!len) | |
- return; | |
- memcpy(buf, text, len); | |
- if(len < olen) | |
- for(i = len; i && i > len - 3; buf[--i] = '.'); | |
- XSetForeground(dpy, dc.gc, col[invert ? ColBG : ColFG]); | |
- if(dc.font.set) | |
- XmbDrawString(dpy, dc.drawable, dc.font.set, dc.gc, x, y, buf,… | |
- else | |
- XDrawString(dpy, dc.drawable, dc.gc, x, y, buf, len); | |
-} | |
- | |
-void | |
enternotify(XEvent *e) { | |
Client *c; | |
Monitor *m; | |
t@@ -848,7 +793,7 @@ focus(Client *c) { | |
detachstack(c); | |
attachstack(c); | |
grabbuttons(c, True); | |
- XSetWindowBorder(dpy, c->win, dc.sel[ColBorder]); | |
+ XSetWindowBorder(dpy, c->win, thmsel->border->rgb); | |
setfocus(c); | |
} | |
else { | |
t@@ -922,16 +867,6 @@ getatomprop(Client *c, Atom prop) { | |
return atom; | |
} | |
-unsigned long | |
-getcolor(const char *colstr) { | |
- Colormap cmap = DefaultColormap(dpy, screen); | |
- XColor color; | |
- | |
- if(!XAllocNamedColor(dpy, cmap, colstr, &color, &color)) | |
- die("error, cannot allocate color '%s'\n", colstr); | |
- return color.pixel; | |
-} | |
- | |
Bool | |
getrootptr(int *x, int *y) { | |
int di; | |
t@@ -1028,40 +963,6 @@ incnmaster(const Arg *arg) { | |
arrange(selmon); | |
} | |
-void | |
-initfont(const char *fontstr) { | |
- char *def, **missing; | |
- int n; | |
- | |
- dc.font.set = XCreateFontSet(dpy, fontstr, &missing, &n, &def); | |
- if(missing) { | |
- while(n--) | |
- fprintf(stderr, "dwm: missing fontset: %s\n", missing[… | |
- XFreeStringList(missing); | |
- } | |
- if(dc.font.set) { | |
- XFontStruct **xfonts; | |
- char **font_names; | |
- | |
- dc.font.ascent = dc.font.descent = 0; | |
- XExtentsOfFontSet(dc.font.set); | |
- n = XFontsOfFontSet(dc.font.set, &xfonts, &font_names); | |
- while(n--) { | |
- dc.font.ascent = MAX(dc.font.ascent, (*xfonts)->ascent… | |
- dc.font.descent = MAX(dc.font.descent,(*xfonts)->desce… | |
- xfonts++; | |
- } | |
- } | |
- else { | |
- if(!(dc.font.xfont = XLoadQueryFont(dpy, fontstr)) | |
- && !(dc.font.xfont = XLoadQueryFont(dpy, "fixed"))) | |
- die("error, cannot load font: '%s'\n", fontstr); | |
- dc.font.ascent = dc.font.xfont->ascent; | |
- dc.font.descent = dc.font.xfont->descent; | |
- } | |
- dc.font.height = dc.font.ascent + dc.font.descent; | |
-} | |
- | |
#ifdef XINERAMA | |
static Bool | |
isuniquegeom(XineramaScreenInfo *unique, size_t n, XineramaScreenInfo *info) { | |
t@@ -1140,7 +1041,7 @@ manage(Window w, XWindowAttributes *wa) { | |
wc.border_width = c->bw; | |
XConfigureWindow(dpy, w, CWBorderWidth, &wc); | |
- XSetWindowBorder(dpy, w, dc.norm[ColBorder]); | |
+ XSetWindowBorder(dpy, w, thmnorm->border->rgb); | |
configure(c); /* propagates border_width, if size doesn't change */ | |
updatewindowtype(c); | |
updatesizehints(c); | |
t@@ -1232,7 +1133,7 @@ movemouse(const Arg *arg) { | |
ocx = c->x; | |
ocy = c->y; | |
if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAs… | |
- None, cursor[CurMove], CurrentTime) != GrabSuccess) | |
+ None, cursor[CurMove]->cursor, CurrentTime) != GrabSuccess) | |
return; | |
if(!getrootptr(&x, &y)) | |
return; | |
t@@ -1378,7 +1279,7 @@ resizemouse(const Arg *arg) { | |
ocx = c->x; | |
ocy = c->y; | |
if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAs… | |
- None, cursor[CurResize], CurrentTime) != GrabSuccess) | |
+ None, cursor[CurResize]->cursor, CurrentTime) != GrabS… | |
return; | |
XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->bw - 1, c->h + c… | |
do { | |
t@@ -1597,10 +1498,12 @@ setup(void) { | |
/* init screen */ | |
screen = DefaultScreen(dpy); | |
root = RootWindow(dpy, screen); | |
- initfont(font); | |
+ fnt = drw_font_create(dpy, font); | |
sw = DisplayWidth(dpy, screen); | |
sh = DisplayHeight(dpy, screen); | |
- bh = dc.h = dc.font.height + 2; | |
+ bh = fnt->h + 2; | |
+ drw = drw_create(dpy, screen, root, sw, sh); | |
+ drw_setfont(drw, fnt); | |
updategeom(); | |
/* init atoms */ | |
wmatom[WMProtocols] = XInternAtom(dpy, "WM_PROTOCOLS", False); | |
t@@ -1616,21 +1519,16 @@ setup(void) { | |
netatom[NetWMWindowTypeDialog] = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE… | |
netatom[NetClientList] = XInternAtom(dpy, "_NET_CLIENT_LIST", False); | |
/* init cursors */ | |
- cursor[CurNormal] = XCreateFontCursor(dpy, XC_left_ptr); | |
- cursor[CurResize] = XCreateFontCursor(dpy, XC_sizing); | |
- cursor[CurMove] = XCreateFontCursor(dpy, XC_fleur); | |
+ cursor[CurNormal] = drw_cur_create(drw, XC_left_ptr); | |
+ cursor[CurResize] = drw_cur_create(drw, XC_sizing); | |
+ cursor[CurMove] = drw_cur_create(drw, XC_fleur); | |
/* init appearance */ | |
- dc.norm[ColBorder] = getcolor(normbordercolor); | |
- dc.norm[ColBG] = getcolor(normbgcolor); | |
- dc.norm[ColFG] = getcolor(normfgcolor); | |
- dc.sel[ColBorder] = getcolor(selbordercolor); | |
- dc.sel[ColBG] = getcolor(selbgcolor); | |
- dc.sel[ColFG] = getcolor(selfgcolor); | |
- dc.drawable = XCreatePixmap(dpy, root, DisplayWidth(dpy, screen), bh, … | |
- dc.gc = XCreateGC(dpy, root, 0, NULL); | |
- XSetLineAttributes(dpy, dc.gc, 1, LineSolid, CapButt, JoinMiter); | |
- if(!dc.font.set) | |
- XSetFont(dpy, dc.gc, dc.font.xfont->fid); | |
+ thmnorm->border = drw_clr_create(drw, normbordercolor); | |
+ thmnorm->bg = drw_clr_create(drw, normbgcolor); | |
+ thmnorm->fg = drw_clr_create(drw, normfgcolor); | |
+ thmsel->border = drw_clr_create(drw, selbordercolor); | |
+ thmsel->bg = drw_clr_create(drw, selbgcolor); | |
+ thmsel->fg = drw_clr_create(drw, selfgcolor); | |
/* init bars */ | |
updatebars(); | |
updatestatus(); | |
t@@ -1639,7 +1537,7 @@ setup(void) { | |
PropModeReplace, (unsigned char *) netatom, NetLast); | |
XDeleteProperty(dpy, root, netatom[NetClientList]); | |
/* select for events */ | |
- wa.cursor = cursor[CurNormal]; | |
+ wa.cursor = cursor[CurNormal]->cursor; | |
wa.event_mask = SubstructureRedirectMask|SubstructureNotifyMask|Button… | |
|EnterWindowMask|LeaveWindowMask|StructureNotifyMask|P… | |
XChangeWindowAttributes(dpy, root, CWEventMask|CWCursor, &wa); | |
t@@ -1699,17 +1597,6 @@ tagmon(const Arg *arg) { | |
sendmon(selmon->sel, dirtomon(arg->i)); | |
} | |
-int | |
-textnw(const char *text, unsigned int len) { | |
- XRectangle r; | |
- | |
- if(dc.font.set) { | |
- XmbTextExtents(dc.font.set, text, len, NULL, &r); | |
- return r.width; | |
- } | |
- return XTextWidth(dc.font.xfont, text, len); | |
-} | |
- | |
void | |
tile(Monitor *m) { | |
unsigned int i, n, h, mw, my, ty; | |
t@@ -1787,7 +1674,7 @@ unfocus(Client *c, Bool setfocus) { | |
if(!c) | |
return; | |
grabbuttons(c, False); | |
- XSetWindowBorder(dpy, c->win, dc.norm[ColBorder]); | |
+ XSetWindowBorder(dpy, c->win, thmnorm->border->rgb); | |
if(setfocus) { | |
XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime); | |
XDeleteProperty(dpy, root, netatom[NetActiveWindow]); | |
t@@ -1846,7 +1733,7 @@ updatebars(void) { | |
m->barwin = XCreateWindow(dpy, root, m->wx, m->by, m->ww, bh, … | |
CopyFromParent, DefaultVisual(dpy, s… | |
CWOverrideRedirect|CWBackPixmap|CWEv… | |
- XDefineCursor(dpy, m->barwin, cursor[CurNormal]); | |
+ XDefineCursor(dpy, m->barwin, cursor[CurNormal]->cursor); | |
XMapRaised(dpy, m->barwin); | |
} | |
} |