git.stevedylan.dev

untested monocle 12ea9250

Anselm R Garbe · 2008-06-19 11:38 4 file(s) · +55 −45

config.def.h +9 −6


static Layout layouts[] = {
	/* symbol     arrange function */
	{ "[]=",      tile }, /* first entry is default */
	{ "><>",      NULL }, /* no layout function means floating behavior */
	{ "[]=",      tile },    /* first entry is default */
	{ "><>",      NULL },    /* no layout function means floating behavior */
	{ "[M]",      monocle }, /* first entry is default */
};

/* key definitions */

	{ MODKEY,                       XK_k,      focusstack,     {.i = -1 } },
	{ MODKEY,                       XK_h,      setmfact,       {.f = -0.05} },
	{ MODKEY,                       XK_l,      setmfact,       {.f = +0.05} },
	{ MODKEY,                       XK_m,      togglemax,      {0} },
	{ MODKEY,                       XK_Return, zoom,           {0} },
	{ MODKEY,                       XK_Tab,    view,           {0} },
	{ MODKEY|ShiftMask,             XK_c,      killclient,     {0} },
	{ MODKEY,                       XK_space,  togglelayout,   {0} },
	{ MODKEY,                       XK_t,      setlayout,      {.v = &layouts[0]} },
	{ MODKEY,                       XK_f,      setlayout,      {.v = &layouts[1]} },
	{ MODKEY,                       XK_m,      setlayout,      {.v = &layouts[2]} },
	{ MODKEY,                       XK_space,  setlayout,      {0} },
	{ MODKEY|ShiftMask,             XK_space,  togglefloating, {0} },
	{ MODKEY,                       XK_0,      view,           {.ui = ~0 } },
	{ MODKEY|ShiftMask,             XK_0,      tag,            {.ui = ~0 } },

 * ClkLtSymbol, ClkStatusText, ClkWinTitle, ClkClientWin, or ClkRootWin */
static Button buttons[] = {
	/* click                event mask      button          function        argument */
	{ ClkLtSymbol,          0,              Button1,        togglelayout,   {0} },
	{ ClkLtSymbol,          0,              Button3,        togglemax,      {0} },
	{ ClkLtSymbol,          0,              Button1,        setlayout,      {0} },
	{ ClkLtSymbol,          0,              Button3,        setlayout,      {.v = &layouts[2]} },
	{ ClkWinTitle,          0,              Button2,        zoom,           {0} },
	{ ClkStatusText,        0,              Button2,        spawn,          {.v = termcmd } },
	{ ClkClientWin,         MODKEY,         Button1,        movemouse,      {0} },

config.mk +1 −1

# dwm version
VERSION = 5.0.1
VERSION = 5.1

# Customize below to fit your system


dwm.1 +10 −1

.B Mod1\-b
Toggles bar on and off.
.TP
.B Mod1\-t
Sets tiled layout.
.TP
.B Mod1\-f
Sets floating layout.
.TP
.B Mod1\-f
Sets monocle layout.
.TP
.B Mod1\-space
Toggles between layouts.
Toggles between current and previous layout.
.TP
.B Mod1\-j
Focus next window.

dwm.c +35 −37

	int basew, baseh, incw, inch, maxw, maxh, minw, minh;
	int bw, oldbw;
	uint tags;
	Bool isbanned, isfixed, isfloating, ismoved, isurgent;
	Bool isbanned, isfixed, isfloating, isurgent;
	Client *next;
	Client *snext;
	Window win;

static void manage(Window w, XWindowAttributes *wa);
static void mappingnotify(XEvent *e);
static void maprequest(XEvent *e);
static void monocle(void);
static void movemouse(const Arg *arg);
static Client *nexttiled(Client *c);
static void propertynotify(XEvent *e);

static void run(void);
static void scan(void);
static void setclientstate(Client *c, long state);
static void setlayout(const Arg *arg);
static void setmfact(const Arg *arg);
static void setup(void);
static void spawn(const Arg *arg);

static void tile(void);
static void togglebar(const Arg *arg);
static void togglefloating(const Arg *arg);
static void togglelayout(const Arg *arg);
static void togglemax(const Arg *arg);
static void toggletag(const Arg *arg);
static void toggleview(const Arg *arg);
static void unmanage(Client *c);

	[UnmapNotify] = unmapnotify
};
static Atom wmatom[WMLast], netatom[NetLast];
static Bool ismax = False;
static Bool otherwm, readin;
static Bool running = True;
static uint tagset[] = {1, 1}; /* after start, first tag is selected */


	for(c = clients; c; c = c->next)
		if(c->tags & tagset[seltags]) { /* is visible */
			if(ismax && !c->isfixed) {
				XMoveResizeWindow(dpy, c->win, wx, wy, ww - 2 * c->bw, wh - 2 * c->bw);
				c->ismoved = True;
			}
			else if(!lt->arrange || c->isfloating)
			if(!lt->arrange || c->isfloating)
				resize(c, c->x, c->y, c->w, c->h, True);
			c->isbanned = False;
		}
		else if(!c->isbanned) {
			XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
			c->isbanned = c->ismoved = True;
			c->isbanned = True;
		}

	focus(NULL);
	if(lt->arrange && !ismax)
	if(lt->arrange)
		lt->arrange();
	restack();
}

	if((c = getclient(ev->window))) {
		if(ev->value_mask & CWBorderWidth)
			c->bw = ev->border_width;
		if(ismax && !c->isbanned && !c->isfixed)
			XMoveResizeWindow(dpy, c->win, wx, wy, ww - 2 * c->bw, wh + 2 * c->bw);
		else if(c->isfloating || !lt->arrange) {
			if(ev->value_mask & CWX)
				c->x = sx + ev->x;

	}
	if(blw > 0) {
		dc.w = blw;
		drawtext(lt->symbol, dc.norm, ismax);
		drawtext(lt->symbol, dc.norm, False);
		x = dc.x + dc.w;
	}
	else

}

void
monocle(void) {
	Client *c;

	for(c = nexttiled(clients); c; c = nexttiled(c->next))
		resize(c, wx, wy, ww, wh, resizehints);
}

void
movemouse(const Arg *arg) {
	int x1, y1, ocx, ocy, di, nx, ny;
	uint dui;

		h = bh;
	if(w < bh)
		w = bh;
	if(c->x != x || c->y != y || c->w != w || c->h != h || c->ismoved) {
		c->ismoved = False;
	if(c->x != x || c->y != y || c->w != w || c->h != h) {
		c->x = wc.x = x;
		c->y = wc.y = y;
		c->w = wc.width = w;

	drawbar();
	if(!sel)
		return;
	if(ismax || sel->isfloating || !lt->arrange)
	if(sel->isfloating || !lt->arrange)
		XRaiseWindow(dpy, sel->win);
	if(!ismax && lt->arrange) {
	if(lt->arrange) {
		wc.stack_mode = Below;
		wc.sibling = barwin;
		for(c = stack; c; c = c->snext)

			PropModeReplace, (unsigned char *)data, 2);
}

void
setlayout(const Arg *arg) {
	static Layout *prevlt = &layouts[1 % LENGTH(layouts)];

	if(!arg || !arg->v || arg->v == lt)
		lt = prevlt;
	else {
		prevlt = lt;
		lt = (Layout *)arg->v;
	}
	if(sel)
		arrange();
	else
		drawbar();
}

/* arg > 1.0 will set mfact absolutly */
void
setmfact(const Arg *arg) {

	sel->isfloating = !sel->isfloating || sel->isfixed;
	if(sel->isfloating)
		resize(sel, sel->x, sel->y, sel->w, sel->h, True);
	arrange();
}

void
togglelayout(const Arg *arg) {
	if(arg && arg->v)
		lt = (Layout *)arg->v;
	else if(++lt == &layouts[LENGTH(layouts)])
		lt = &layouts[0];
	if(sel)
		arrange();
	else
		drawbar();
}

void
togglemax(const Arg *arg) {
	ismax = !ismax;
	arrange();
}


zoom(const Arg *arg) {
	Client *c = sel;

	if(ismax || !lt->arrange || (sel && sel->isfloating))
	if(!lt->arrange || lt->arrange == monocle || (sel && sel->isfloating))
		return;
	if(c == nexttiled(clients))
		if(!c || !(c = nexttiled(c->next)))

32	32
33	33		static Layout layouts[] = {
34	34		/* symbol arrange function */
35		-	{ "[]=", tile }, /* first entry is default */
36		-	{ "><>", NULL }, /* no layout function means floating behavior */
	35	+	{ "[]=", tile }, /* first entry is default */
	36	+	{ "><>", NULL }, /* no layout function means floating behavior */
	37	+	{ "[M]", monocle }, /* first entry is default */
37	38		};
38	39
39	40		/* key definitions */

60	61		{ MODKEY, XK_k, focusstack, {.i = -1 } },
61	62		{ MODKEY, XK_h, setmfact, {.f = -0.05} },
62	63		{ MODKEY, XK_l, setmfact, {.f = +0.05} },
63		-	{ MODKEY, XK_m, togglemax, {0} },
64	64		{ MODKEY, XK_Return, zoom, {0} },
65	65		{ MODKEY, XK_Tab, view, {0} },
66	66		{ MODKEY\|ShiftMask, XK_c, killclient, {0} },
67		-	{ MODKEY, XK_space, togglelayout, {0} },
	67	+	{ MODKEY, XK_t, setlayout, {.v = &layouts[0]} },
	68	+	{ MODKEY, XK_f, setlayout, {.v = &layouts[1]} },
	69	+	{ MODKEY, XK_m, setlayout, {.v = &layouts[2]} },
	70	+	{ MODKEY, XK_space, setlayout, {0} },
68	71		{ MODKEY\|ShiftMask, XK_space, togglefloating, {0} },
69	72		{ MODKEY, XK_0, view, {.ui = ~0 } },
70	73		{ MODKEY\|ShiftMask, XK_0, tag, {.ui = ~0 } },

91	94		* ClkLtSymbol, ClkStatusText, ClkWinTitle, ClkClientWin, or ClkRootWin */
92	95		static Button buttons[] = {
93	96		/* click event mask button function argument */
94		-	{ ClkLtSymbol, 0, Button1, togglelayout, {0} },
95		-	{ ClkLtSymbol, 0, Button3, togglemax, {0} },
	97	+	{ ClkLtSymbol, 0, Button1, setlayout, {0} },
	98	+	{ ClkLtSymbol, 0, Button3, setlayout, {.v = &layouts[2]} },
96	99		{ ClkWinTitle, 0, Button2, zoom, {0} },
97	100		{ ClkStatusText, 0, Button2, spawn, {.v = termcmd } },
98	101		{ ClkClientWin, MODKEY, Button1, movemouse, {0} },

60	60		.B Mod1\-b
61	61		Toggles bar on and off.
62	62		.TP
	63	+	.B Mod1\-t
	64	+	Sets tiled layout.
	65	+	.TP
	66	+	.B Mod1\-f
	67	+	Sets floating layout.
	68	+	.TP
	69	+	.B Mod1\-f
	70	+	Sets monocle layout.
	71	+	.TP
63	72		.B Mod1\-space
64		-	Toggles between layouts.
	73	+	Toggles between current and previous layout.
65	74		.TP
66	75		.B Mod1\-j
67	76		Focus next window.

89	89		int basew, baseh, incw, inch, maxw, maxh, minw, minh;
90	90		int bw, oldbw;
91	91		uint tags;
92		-	Bool isbanned, isfixed, isfloating, ismoved, isurgent;
	92	+	Bool isbanned, isfixed, isfloating, isurgent;
93	93		Client *next;
94	94		Client *snext;
95	95		Window win;

168	168		static void manage(Window w, XWindowAttributes *wa);
169	169		static void mappingnotify(XEvent *e);
170	170		static void maprequest(XEvent *e);
	171	+	static void monocle(void);
171	172		static void movemouse(const Arg *arg);
172	173		static Client nexttiled(Client c);
173	174		static void propertynotify(XEvent *e);

178	179		static void run(void);
179	180		static void scan(void);
180	181		static void setclientstate(Client *c, long state);
	182	+	static void setlayout(const Arg *arg);
181	183		static void setmfact(const Arg *arg);
182	184		static void setup(void);
183	185		static void spawn(const Arg *arg);

186	188		static void tile(void);
187	189		static void togglebar(const Arg *arg);
188	190		static void togglefloating(const Arg *arg);
189		-	static void togglelayout(const Arg *arg);
190		-	static void togglemax(const Arg *arg);
191	191		static void toggletag(const Arg *arg);
192	192		static void toggleview(const Arg *arg);
193	193		static void unmanage(Client *c);

225	225		[UnmapNotify] = unmapnotify
226	226		};
227	227		static Atom wmatom[WMLast], netatom[NetLast];
228		-	static Bool ismax = False;
229	228		static Bool otherwm, readin;
230	229		static Bool running = True;
231	230		static uint tagset[] = {1, 1}; /* after start, first tag is selected */

275	274
276	275		for(c = clients; c; c = c->next)
277	276		if(c->tags & tagset[seltags]) { /* is visible */
278		-	if(ismax && !c->isfixed) {
279		-	XMoveResizeWindow(dpy, c->win, wx, wy, ww - 2 * c->bw, wh - 2 * c->bw);
280		-	c->ismoved = True;
281		-	}
282		-	else if(!lt->arrange \|\| c->isfloating)
	277	+	if(!lt->arrange \|\| c->isfloating)
283	278		resize(c, c->x, c->y, c->w, c->h, True);
284	279		c->isbanned = False;
285	280		}
286	281		else if(!c->isbanned) {
287	282		XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
288		-	c->isbanned = c->ismoved = True;
	283	+	c->isbanned = True;
289	284		}
290	285
291	286		focus(NULL);
292		-	if(lt->arrange && !ismax)
	287	+	if(lt->arrange)
293	288		lt->arrange();
294	289		restack();
295	290		}

418	413		if((c = getclient(ev->window))) {
419	414		if(ev->value_mask & CWBorderWidth)
420	415		c->bw = ev->border_width;
421		-	if(ismax && !c->isbanned && !c->isfixed)
422		-	XMoveResizeWindow(dpy, c->win, wx, wy, ww - 2 * c->bw, wh + 2 * c->bw);
423	416		else if(c->isfloating \|\| !lt->arrange) {
424	417		if(ev->value_mask & CWX)
425	418		c->x = sx + ev->x;

507	500		}
508	501		if(blw > 0) {
509	502		dc.w = blw;
510		-	drawtext(lt->symbol, dc.norm, ismax);
	503	+	drawtext(lt->symbol, dc.norm, False);
511	504		x = dc.x + dc.w;
512	505		}
513	506		else

967	960		}
968	961
969	962		void
	963	+	monocle(void) {
	964	+	Client *c;
	965	+
	966	+	for(c = nexttiled(clients); c; c = nexttiled(c->next))
	967	+	resize(c, wx, wy, ww, wh, resizehints);
	968	+	}
	969	+
	970	+	void
970	971		movemouse(const Arg *arg) {
971	972		int x1, y1, ocx, ocy, di, nx, ny;
972	973		uint dui;

1115	1116		h = bh;
1116	1117		if(w < bh)
1117	1118		w = bh;
1118		-	if(c->x != x \|\| c->y != y \|\| c->w != w \|\| c->h != h \|\| c->ismoved) {
1119		-	c->ismoved = False;
	1119	+	if(c->x != x \|\| c->y != y \|\| c->w != w \|\| c->h != h) {
1120	1120		c->x = wc.x = x;
1121	1121		c->y = wc.y = y;
1122	1122		c->w = wc.width = w;

1186	1186		drawbar();
1187	1187		if(!sel)
1188	1188		return;
1189		-	if(ismax \|\| sel->isfloating \|\| !lt->arrange)
	1189	+	if(sel->isfloating \|\| !lt->arrange)
1190	1190		XRaiseWindow(dpy, sel->win);
1191		-	if(!ismax && lt->arrange) {
	1191	+	if(lt->arrange) {
1192	1192		wc.stack_mode = Below;
1193	1193		wc.sibling = barwin;
1194	1194		for(c = stack; c; c = c->snext)

1296	1296		PropModeReplace, (unsigned char *)data, 2);
1297	1297		}
1298	1298
	1299	+	void
	1300	+	setlayout(const Arg *arg) {
	1301	+	static Layout *prevlt = &layouts[1 % LENGTH(layouts)];
	1302	+
	1303	+	if(!arg \|\| !arg->v \|\| arg->v == lt)
	1304	+	lt = prevlt;
	1305	+	else {
	1306	+	prevlt = lt;
	1307	+	lt = (Layout *)arg->v;
	1308	+	}
	1309	+	if(sel)
	1310	+	arrange();
	1311	+	else
	1312	+	drawbar();
	1313	+	}
	1314	+
1299	1315		/* arg > 1.0 will set mfact absolutly */
1300	1316		void
1301	1317		setmfact(const Arg *arg) {

1473	1489		sel->isfloating = !sel->isfloating \|\| sel->isfixed;
1474	1490		if(sel->isfloating)
1475	1491		resize(sel, sel->x, sel->y, sel->w, sel->h, True);
1476		-	arrange();
1477		-	}
1478		-
1479		-	void
1480		-	togglelayout(const Arg *arg) {
1481		-	if(arg && arg->v)
1482		-	lt = (Layout *)arg->v;
1483		-	else if(++lt == &layouts[LENGTH(layouts)])
1484		-	lt = &layouts[0];
1485		-	if(sel)
1486		-	arrange();
1487		-	else
1488		-	drawbar();
1489		-	}
1490		-
1491		-	void
1492		-	togglemax(const Arg *arg) {
1493		-	ismax = !ismax;
1494	1492		arrange();
1495	1493		}
1496	1494

1693	1691		zoom(const Arg *arg) {
1694	1692		Client *c = sel;
1695	1693
1696		-	if(ismax \|\| !lt->arrange \|\| (sel && sel->isfloating))
	1694	+	if(!lt->arrange \|\| lt->arrange == monocle \|\| (sel && sel->isfloating))
1697	1695		return;
1698	1696		if(c == nexttiled(clients))
1699	1697		if(!c \|\| !(c = nexttiled(c->next)))

1	1		# dwm version
2		-	VERSION = 5.0.1
	2	+	VERSION = 5.1
3	3
4	4		# Customize below to fit your system
5	5