enum { SchemeNorm, SchemeSel, SchemeLast }; /* color schemes */
enum { NetSupported, NetWMName, NetWMState,
NetWMFullscreen, NetWMWindowOpacity, NetActiveWindow, NetWMWindowType,
- NetWMWindowTypeDialog, NetClientList, NetLast }; /* EWMH atoms */
+ NetWMWindowTypeDialog, NetClientList, NetSupportingWMCheck, NetLast }; /* EWMH atoms */
enum { WMProtocols, WMDelete, WMState, WMTakeFocus, WMLast }; /* default atoms */
enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle,
ClkClientWin, ClkRootWin, ClkLast }; /* clicks */
int oldx, oldy, oldw, oldh;
int basew, baseh, incw, inch, maxw, maxh, minw, minh;
int bw, oldbw;
+ int opacity;
unsigned int tags;
Bool isfixed, isfloating, isurgent, neverfocus, oldstate, isfullscreen, screen_hog;
Client *next;
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 grab_typing_keys(void);
static void incnmaster(const Arg *arg);
static void keypress(XEvent *e);
static void killclient(const Arg *arg);
static void motionnotify(XEvent *e);
static void movemouse(const Arg *arg);
static Client *nexttiled(Client *c);
+static Client *snexttiled(Client *c);
static Client *nextvisible(Client *c);
static void pop(Client *);
static void propertynotify(XEvent *e);
static void quit(const Arg *arg);
static Monitor *recttomon(int x, int y, int w, int h);
-static void resize(Client *c, int x, int y, int w, int h, Bool interact);
-static void resizeclient(Client *c, int x, int y, int w, int h);
+static void resize(Client *c, int x, int y, int w, int h, Bool interact, Client *base);
+static void resizeclient(Client *c, int x, int y, int w, int h, Client *base);
static void resizemouse(const Arg *arg);
static void restack(Monitor *m);
static void run(void);
static void scan(void);
static Bool sendevent(Client *c, Atom proto);
+static void send_keycode(KeyCode key);
static void sendmon(Client *c, Monitor *m);
static void setclientstate(Client *c, long state);
static void setfocus(Client *c);
static void zoom(const Arg *arg);
/* variables */
+static KeyCode key_buffer[100];
+static int key_buffer_len = 0;
+static Bool key_buffering = False;
static const char broken[] = "broken";
static char stext[256];
static int screen;
static Window root;
// unfocused windows get transparent (feature)
-static const unsigned long unfocused_opacity[] = { 0xbfffffff };
-static const unsigned long invisible_opacity[] = { 0x00000000 };
+static const unsigned long opacities[] = { 0, 0xbfffffff, 0x00000000 }; // first unused
static void window_set_opaque(Client *c);
static void window_set_translucent(Client *c);
static void window_set_invisible(Client *c);
+static void window_set_opacity(Client *c, int opacity_index);
+static void update_window_opacities(Monitor *m);
+void
+window_set_opacity(Client *c, int opacity_index) {
+ if (c->opacity == opacity_index) {
+ return;
+ }
+ c->opacity = opacity_index;
+ if (opacity_index == 0) {
+ XDeleteProperty(dpy, c->win, netatom[NetWMWindowOpacity]);
+ } else {
+ XChangeProperty(dpy, c->win, netatom[NetWMWindowOpacity], XA_CARDINAL, 32, PropModeReplace, (unsigned char *)(&opacities[opacity_index]), 1);
+ }
+}
void
window_set_opaque(Client *c) {
- XDeleteProperty(dpy, c->win, netatom[NetWMWindowOpacity]);
+ window_set_opacity(c, 0);
}
void
window_set_translucent(Client *c) {
- XChangeProperty(dpy, c->win, netatom[NetWMWindowOpacity], XA_CARDINAL, 32, PropModeReplace, (unsigned char *)unfocused_opacity, 1);
+ window_set_opacity(c, 1);
}
void
window_set_invisible(Client *c) {
- XChangeProperty(dpy, c->win, netatom[NetWMWindowOpacity], XA_CARDINAL, 32, PropModeReplace, (unsigned char *)invisible_opacity, 1);
+ window_set_opacity(c, 2);
+}
+void
+update_window_opacities(Monitor *m) {
+ Client *master, *slave, *c;
+ Bool selection_floating = False;
+ slave = master = nexttiled(m->clients);
+ if (master) slave = nexttiled(master->next);
+ if (m->sel && m->sel != master) {
+ if (nexttiled(m->sel) == m->sel) // if selection is tiled
+ slave = m->sel;
+ else
+ selection_floating = True;
+ }
+ for (c = m->clients; c; c = c->next) {
+ if (ISVISIBLE(c)) {
+ if (c->isfloating || c == m->sel || (selection_floating && (c == master || c == slave))) {
+ window_set_opaque(c);
+ } else if (c == master || c == slave) {
+ window_set_translucent(c);
+ } else {
+ window_set_opaque(c);
+ }
+ }
+ }
}
Bool
applysizehints(Client *c, int *x, int *y, int *w, int *h, Bool interact) {
Bool baseismin;
- Monitor *m = c->mon;
+ // Monitor *m = c->mon;
/* set minimum possible */
*w = MAX(1, *w);
if(*y + *h + 2 * c->bw < 0)
*y = 0;
}
- else {
- if(*x >= m->wx + m->ww)
- *x = m->wx + m->ww - WIDTH(c);
- if(*y >= m->wy + m->wh)
- *y = m->wy + m->wh - HEIGHT(c);
- if(*x + *w + 2 * c->bw <= m->wx)
- *x = m->wx;
- if(*y + *h + 2 * c->bw <= m->wy)
- *y = m->wy;
- }
+ // jason: let windows be offscreen
+ //else {
+ // if(*x >= m->wx + m->ww)
+ // *x = m->wx + m->ww - WIDTH(c);
+ // if(*y >= m->wy + m->wh)
+ // *y = m->wy + m->wh - HEIGHT(c);
+ // if(*x + *w + 2 * c->bw <= m->wx)
+ // *x = m->wx;
+ // if(*y + *h + 2 * c->bw <= m->wy)
+ // *y = m->wy;
+ //}
if(*h < bh)
*h = bh;
if(*w < bh)
|| (cme->data.l[0] == 2 /* _NET_WM_STATE_TOGGLE */ && !c->isfullscreen)));
}
else if(cme->message_type == netatom[NetActiveWindow]) {
+ // Jason added this so apps can't steal focus:
return;
if(!ISVISIBLE(c)) {
c->mon->seltags ^= 1;
Monitor *m;
XCrossingEvent *ev = &e->xcrossing;
+ return; // jason: added to stop mouse focus
+
if((ev->mode != NotifyNormal || ev->detail == NotifyInferior) && ev->window != root)
return;
c = wintoclient(ev->window);
XDeleteProperty(dpy, root, netatom[NetActiveWindow]);
}
selmon->sel = c;
+ arrange(selmon);
+ update_window_opacities(selmon);
drawbars();
if(c && (!root || (c->win!=root)) )
window_set_opaque(c);
for(j = 0; j < LENGTH(modifiers); j++)
XGrabKey(dpy, code, keys[i].mod | modifiers[j], root,
True, GrabModeAsync, GrabModeAsync);
+ if(key_buffering)
+ grab_typing_keys();
+ }
+}
+
+void
+grab_typing_keys(void) {
+ updatenumlockmask();
+ {
+ unsigned int i, j;
+ unsigned int modifiers[] = { 0, LockMask, numlockmask, numlockmask|LockMask };
+ KeySym typing_keys[] = {
+ XK_space, XK_Return, XK_period, XK_slash, XK_minus, XK_apostrophe,
+ XK_A, XK_B, XK_C, XK_D, XK_E, XK_F, XK_G, XK_H, XK_I, XK_J, XK_K,
+ XK_L, XK_M, XK_N, XK_O, XK_P, XK_Q, XK_R, XK_S, XK_T, XK_U, XK_V,
+ XK_W, XK_X, XK_Y, XK_Z, XK_0, XK_1, XK_2, XK_3, XK_4, XK_5, XK_6,
+ XK_7, XK_8, XK_9,
+ };
+
+ KeyCode code;
+
+ for(i = 0; i < LENGTH(typing_keys); i++)
+ if((code = XKeysymToKeycode(dpy, typing_keys[i])))
+ for(j = 0; j < LENGTH(modifiers); j++)
+ XGrabKey(dpy, code, modifiers[j], root,
+ True, GrabModeAsync, GrabModeAsync);
}
}
#endif /* XINERAMA */
void
+send_keycode(KeyCode key) {
+ XKeyEvent event;
+ if(!selmon->sel) {
+ return;
+ }
+ event.display = dpy;
+ event.root = root;
+ event.window = selmon->sel->win;
+ event.subwindow = None;
+ event.same_screen = True;
+ event.x = 1;
+ event.y = 1;
+ event.x_root = 1;
+ event.y_root = 1;
+ event.time = CurrentTime;
+ event.state = 0; // modifiers
+ event.keycode = key;
+ event.type = KeyPress;
+ XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event);
+ event.type = KeyRelease;
+ XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event);
+}
+
+void
keypress(XEvent *e) {
unsigned int i;
KeySym keysym;
XKeyEvent *ev;
+ Bool called = False;
ev = &e->xkey;
keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);
for(i = 0; i < LENGTH(keys); i++)
if(keysym == keys[i].keysym
&& CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
- && keys[i].func)
+ && keys[i].func) {
keys[i].func(&(keys[i].arg));
+ called = True;
+ }
+ if(!called) {
+ if(key_buffering) {
+ if(key_buffer_len == LENGTH(key_buffer)) {
+ // buffer full, bail
+ key_buffer_len = 0;
+ key_buffering = False;
+ grabkeys(); // stop grabbing typing keys
+ } else {
+ key_buffer[key_buffer_len] = (KeyCode)ev->keycode;
+ key_buffer_len += 1;
+ }
+ } else {
+ send_keycode(ev->keycode);
+ }
+ }
}
void
Client *c, *t = NULL;
Window trans = None;
XWindowChanges wc;
+ int i;
if(!(c = calloc(1, sizeof(Client))))
die("fatal: could not malloc() %u bytes\n", sizeof(Client));
+ c->opacity = -1; // who knows
c->win = w;
updatetitle(c);
if(XGetTransientForHint(dpy, w, &trans) && (t = wintoclient(trans))) {
arrange(c->mon);
XMapWindow(dpy, c->win);
focus(c);
+ if(key_buffering) {
+ key_buffering = False;
+ grabkeys(); // stop grabbing typing keys
+ if(key_buffer_len > 0) {
+ for(i = 0; i < key_buffer_len; ++i) {
+ send_keycode(key_buffer[i]);
+ }
+ }
+ key_buffer_len = 0;
+ }
}
void
n++;
if(n > 0) /* override layout symbol */
snprintf(m->ltsymbol, sizeof m->ltsymbol, "[%d]", n);
- for(c = nexttiled(m->clients); c; c = nexttiled(c->next))
- resize(c, m->wx, m->wy, m->ww - 2 * c->bw, m->wh - 2 * c->bw, False);
+ for(c = snexttiled(m->stack); c; c = snexttiled(c->snext)) {
+ if (c == m->sel) {
+ resize(c, m->wx, m->wy, m->ww - 2 * c->bw, m->wh - 2 * c->bw, False, 0);
+ } else {
+ // this window is should not be visible. move off top, but don't change h/w
+ resize(c, m->wx, m->wy - 4000, c->w, c->h, False, 0);
+ }
+ }
}
void
togglefloating(NULL);
}
if(!selmon->lt[selmon->sellt]->arrange || c->isfloating)
- resize(c, nx, ny, c->w, c->h, True);
+ resize(c, nx, ny, c->w, c->h, True, 0);
break;
}
} while(ev.type != ButtonRelease);
}
Client *
+snexttiled(Client *c) {
+ for(; c && (c->isfloating || !ISVISIBLE(c)); c = c->snext);
+ return c;
+}
+
+Client *
nextvisible(Client *c) {
for(; c && !ISVISIBLE(c); c = c->next);
return c;
}
void
-resize(Client *c, int x, int y, int w, int h, Bool interact) {
+resize(Client *c, int x, int y, int w, int h, Bool interact, Client *base) {
if(applysizehints(c, &x, &y, &w, &h, interact))
- resizeclient(c, x, y, w, h);
+ resizeclient(c, x, y, w, h, base);
}
void
-resizeclient(Client *c, int x, int y, int w, int h) {
+resizeclient(Client *c, int x, int y, int w, int h, Client *base) {
XWindowChanges wc;
+ unsigned long mask = CWX|CWY|CWWidth|CWHeight|CWBorderWidth;
c->oldx = c->x; c->x = wc.x = x;
c->oldy = c->y; c->y = wc.y = y;
c->oldw = c->w; c->w = wc.width = w;
c->oldh = c->h; c->h = wc.height = h;
+ // base = 0;
+ if (base) {
+ wc.stack_mode = Above;
+ wc.sibling = base->win;
+ mask |= CWStackMode|CWSibling;
+ }
wc.border_width = c->bw;
- XConfigureWindow(dpy, c->win, CWX|CWY|CWWidth|CWHeight|CWBorderWidth, &wc);
+ XConfigureWindow(dpy, c->win, mask, &wc);
configure(c);
XSync(dpy, False);
}
togglefloating(NULL);
}
if(!selmon->lt[selmon->sellt]->arrange || c->isfloating)
- resize(c, c->x, c->y, nw, nh, True);
+ resize(c, c->x, c->y, nw, nh, True, 0);
break;
}
} while(ev.type != ButtonRelease);
if(m->lt[m->sellt]->arrange) {
wc.stack_mode = Below;
wc.sibling = m->barwin;
- for(c = m->stack; c; c = c->snext)
+ for(c = m->clients; c; c = c->next)
if(!c->isfloating && ISVISIBLE(c)) {
XConfigureWindow(dpy, c->win, CWSibling|CWStackMode, &wc);
wc.sibling = c->win;
+ wc.stack_mode = Above;
}
}
XSync(dpy, False);
c->oldbw = c->bw;
c->bw = 0;
c->isfloating = True;
- resizeclient(c, c->mon->mx, c->mon->my, c->mon->mw, c->mon->mh);
+ resizeclient(c, c->mon->mx, c->mon->my, c->mon->mw, c->mon->mh, 0);
XRaiseWindow(dpy, c->win);
}
else {
c->y = c->oldy;
c->w = c->oldw;
c->h = c->oldh;
- resizeclient(c, c->x, c->y, c->w, c->h);
+ resizeclient(c, c->x, c->y, c->w, c->h, 0);
arrange(c->mon);
}
}
netatom[NetWMWindowType] = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE", False);
netatom[NetWMWindowTypeDialog] = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE_DIALOG", False);
netatom[NetClientList] = XInternAtom(dpy, "_NET_CLIENT_LIST", False);
+ netatom[NetSupportingWMCheck] = XInternAtom(dpy, "_NET_SUPPORTING_WM_CHECK", False);
+ XInternAtom(dpy, "_MOTIF_WM_HINTS", False); /* clients may request borderless/fullscreen */
/* init cursors */
cursor[CurNormal] = drw_cur_create(drw, XC_left_ptr);
cursor[CurResize] = drw_cur_create(drw, XC_sizing);
if(ISVISIBLE(c)) { /* show clients top down */
XMoveWindow(dpy, c->win, c->x, c->y);
if((!c->mon->lt[c->mon->sellt]->arrange || c->isfloating) && !c->isfullscreen)
- resize(c, c->x, c->y, c->w, c->h, False);
+ resize(c, c->x, c->y, c->w, c->h, False, 0);
showhide(c->snext);
}
else { /* hide clients bottom up */
break;
}
}
- _SWM_WS[8] = swm_tags[tag][0];
- _SWM_WS[9] = swm_tags[tag][1];
+ WORKSPACE_NUMBER[17] = workspace_numbers_str[tag][0];
+ WORKSPACE_NUMBER[18] = workspace_numbers_str[tag][1];
}
if(arg->v == dmenucmd)
dmenumon[0] = '0' + selmon->num;
+ key_buffering = True;
+ key_buffer_len = 0;
+ grab_typing_keys();
if(fork() == 0) {
if(dpy)
close(ConnectionNumber(dpy));
for(i = my = ty = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++)
if(i < m->nmaster) {
h = (m->wh - my) / (MIN(n, m->nmaster) - i);
- resize(c, m->wx, m->wy + my, mw - (2*c->bw), h - (2*c->bw), False);
+ resize(c, m->wx, m->wy + my, mw - (2*c->bw), h - (2*c->bw), False, 0);
my += HEIGHT(c);
}
else {
h = (m->wh - ty) / (n - i);
- resize(c, m->wx + mw, m->wy + ty, m->ww - mw - (2*c->bw), h - (2*c->bw), False);
+ resize(c, m->wx + mw, m->wy + ty, m->ww - mw - (2*c->bw), h - (2*c->bw), False, 0);
ty += HEIGHT(c);
}
}
+#define TAB_HEIGHT 19
+#define TAB_PAD 7
+
void
jason_layout(Monitor *m) {
- unsigned int i, n, mw;
- Client *c, *vis_slave;
+ unsigned int i, tiled_count, mw, right_width, tab_counts[2] = {0,0}, cur_tab = 0, *tab_count;
+ int tab_top;
+ Client *c, *vis_slave = 0, *base = 0;
- for(n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++);
- if(n == 0) {
+ tab_count = &(tab_counts[0]);
+
+ for(tiled_count = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), tiled_count++) {
+ if (tiled_count == 0) { // master
+ if (c->next) {
+ if (m->sel && (m->sel == c || m->sel->isfloating || !ISVISIBLE(m->sel))) {
+ vis_slave = nexttiled(c->next);
+ } else {
+ vis_slave = m->sel;
+ }
+ }
+ } else {
+ if (c == vis_slave) {
+ tab_count = &(tab_counts[1]);
+ } else {
+ (*tab_count) += 1;
+ }
+ }
+ }
+ if(tiled_count == 0) {
return;
}
- c = nexttiled(m->clients);
- if (c == m->sel) {
- // if master is selected, show first slave
- vis_slave = nexttiled(c->next);
- } else {
- vis_slave = m->sel;
- }
- if(n > 1 || (n == 1 && !c->screen_hog)) {
+ if(tiled_count > 1 || (tiled_count == 1 && !nexttiled(m->clients)->screen_hog)) {
mw = m->ww * m->mfact;
} else {
- // one of these:
- // * zero tiled windows
- // * one tiled window that's not a screen hog
- // * miltiple tiled windows
mw = m->ww;
}
+ right_width = m->ww - mw;
+ tab_count = &(tab_counts[0]);
+ tab_top = m->wy - (m->wh - (2 * (TAB_HEIGHT + TAB_PAD))) + TAB_HEIGHT;
for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++) {
if (i == 0) {
- resize(c, m->wx, m->wy, mw, m->wh, False);
+ resize(c, m->wx, m->wy, mw, m->wh, False, 0);
} else {
if (c == vis_slave) {
- resize(c, m->wx + mw, m->wy, m->ww - mw, m->wh, False);
+ resize(c, m->wx + mw, m->wy + TAB_HEIGHT + TAB_PAD, right_width, m->wh - 2 * (TAB_HEIGHT + TAB_PAD), False, base);
+ tab_count = &(tab_counts[1]);
+ tab_top = m->wy + m->wh - TAB_HEIGHT;
+ cur_tab = 0;
} else {
// this function does not get called when focus changes
// resize(c, m->wx + m->ww, m->wy, m->ww - mw, m->wh, False);
- resize(c, m->wx + mw, m->wy, m->ww - mw, m->wh, False);
+ resize(c, m->wx + mw + right_width * cur_tab / (*tab_count), tab_top, right_width, m->wh - 2 * (TAB_HEIGHT + TAB_PAD), False, base);
+ cur_tab += 1;
}
}
+ base = c;
}
}
selmon->sel->isfloating = !selmon->sel->isfloating || selmon->sel->isfixed;
if(selmon->sel->isfloating)
resize(selmon->sel, selmon->sel->x, selmon->sel->y,
- selmon->sel->w, selmon->sel->h, False);
+ selmon->sel->w, selmon->sel->h, False, 0);
arrange(selmon);
}
void
unfocus(Client *c, Bool setfocus) {
- Client *w;
if(!c)
return;
- if(!root || c->win!=root) {
- w = nexttiled(c->mon->clients);
- if (!w) {
- // no tiled windows
- window_set_translucent(c);
- } else if (w == c) {
- // master
- window_set_translucent(c);
- } else {
- w = nexttiled(w->next);
- if (!w) {
- // c must not be tiled
- window_set_translucent(c);
- } else {
- if (w == c) { // first slave
- window_set_translucent(c);
- } else {
- window_set_invisible(c);
- window_set_translucent(w);
- }
- }
- }
- }
grabbuttons(c, False);
XSetWindowBorder(dpy, c->win, scheme[SchemeNorm].border->rgb);
if(setfocus) {
m->barwin = XCreateWindow(dpy, root, m->wx, m->by, m->ww, bh, 0, DefaultDepth(dpy, screen),
CopyFromParent, DefaultVisual(dpy, screen),
CWOverrideRedirect|CWBackPixmap|CWEventMask, &wa);
+ XChangeProperty(dpy, root, netatom[NetSupportingWMCheck], XA_WINDOW, 32,
+ PropModeReplace, (unsigned char *) &(m->barwin), 1);
+ XChangeProperty(dpy, m->barwin, netatom[NetSupportingWMCheck], XA_WINDOW, 32,
+ PropModeReplace, (unsigned char *) &(m->barwin), 1);
+ XChangeProperty(dpy, m->barwin, netatom[NetWMName], XA_STRING, 8,
+ PropModeReplace, (unsigned char *) "dwm", 3);
XDefineCursor(dpy, m->barwin, cursor[CurNormal]->cursor);
XMapRaised(dpy, m->barwin);
}
Got questions, comments, patches, etc.? Contact Jason Woofenden