git.stevedylan.dev

added the new dotile as described on ml fee8df6c

Anselm R. Garbe · 2006-09-29 16:22 6 file(s) · +112 −36

config.arg.h +2 −0

	{ MODKEY,			XK_j,		focusnext,	{ 0 } }, \
	{ MODKEY,			XK_k,		focusprev,	{ 0 } }, \
	{ MODKEY,			XK_Return,	zoom,		{ 0 } }, \
	{ MODKEY,			XK_b,		togglestackpos,	{ 0 } }, \
	{ MODKEY,			XK_d,		togglestackdir,	{ 0 } }, \
	{ MODKEY,			XK_g,		resizecol,	{ .i = 20 } }, \
	{ MODKEY,			XK_s,		resizecol,	{ .i = -20 } }, \
	{ MODKEY|ShiftMask,		XK_1,		tag,		{ .i = 0 } }, \

config.default.h +2 −0

	{ MODKEY,			XK_Tab,		focusnext,	{ 0 } }, \
	{ MODKEY|ShiftMask,		XK_Tab,		focusprev,	{ 0 } }, \
	{ MODKEY,			XK_Return,	zoom,		{ 0 } }, \
	{ MODKEY,			XK_b,		togglestackpos,	{ 0 } }, \
	{ MODKEY,			XK_d,		togglestackdir,	{ 0 } }, \
	{ MODKEY,			XK_g,		resizecol,	{ .i = 20 } }, \
	{ MODKEY,			XK_s,		resizecol,	{ .i = -20 } }, \
	{ MODKEY|ShiftMask,		XK_1,		tag,		{ .i = 0 } }, \

dwm.h +6 −3

extern const char *tags[];			/* all tags */
extern char stext[1024];			/* status text */
extern int bx, by, bw, bh, bmw;			/* bar geometry, bar mode label width */
extern int master, screen, sx, sy, sw, sh;	/* screen geometry, master width */
extern int master, screen, sx, sy, sw, sh;	/* screen geometry, master dimension*/
extern unsigned int ntags, numlockmask;		/* number of tags, dynamic lock mask */
extern void (*handler[LASTEvent])(XEvent *);	/* event handler */
extern void (*arrange)(Arg *);			/* arrange function, indicates mode  */

extern void focusnext(Arg *arg);		/* focuses next visible client, arg is ignored  */
extern void focusprev(Arg *arg);		/* focuses previous visible client, arg is ignored */
extern Bool isvisible(Client *c);		/* returns True if client is visible */
extern void resizecol(Arg *arg);		/* resizes the master width with arg's index value */
extern void resizecol(Arg *arg);		/* resizes the master dimension with arg's index value */
extern void restack(void);			/* restores z layers of all clients */
extern void togglestackdir(Arg *arg);		/* toggles stack direction */
extern void togglestackpos(Arg *arg);		/* toggles stack position */
extern void togglemode(Arg *arg);		/* toggles global arrange function (dotile/dofloat) */
extern void toggleview(Arg *arg);		/* toggles the tag with arg's index (in)visible */
extern void updatemaster(void);			/* updates master dimension */
extern void view(Arg *arg);			/* views the tag with arg's index */
extern void viewall(Arg *arg);			/* views all tags, arg is ignored */
extern void zoom(Arg *arg);			/* zooms the focused client to master column, arg is ignored */
extern void zoom(Arg *arg);			/* zooms the focused client to master area, arg is ignored */

event.c +3 −2

			configure(c);
		XSync(dpy, False);
		if(c->isfloat) {
			if(isvisible(c))
				resize(c, False, TopLeft);
			resize(c, False, TopLeft);
			if(!isvisible(c))
				ban(c);
		}
		else
			arrange(NULL);

main.c +1 −1

	sx = sy = 0;
	sw = DisplayWidth(dpy, screen);
	sh = DisplayHeight(dpy, screen);
	master = ((stackpos == StackBottom ? sh - bh : sw) * MASTER) / 100;
	updatemaster();

	bx = by = 0;
	bw = sw;

view.c +98 −30

				c->h = sh - 2 * BORDERPX - bh;
			}
			else if(i == 0) { /* master window */
				c->x = sx;
				if(stackpos == StackLeft)
					c->x += master;
				c->y = sy + bh;
				if(isvertical) {
				switch(stackpos) {
				case StackLeft:
					c->x = sx + stackw;
					c->y = sy + bh;
					c->w = master - 2 * BORDERPX;
					c->h = sh - 2 * BORDERPX - bh;
				}
				else {
					c->w = sw;
					c->h = sh - bh - 2 * BORDERPX;
					break;
				case StackBottom:
					c->x = sx;
					c->y = sy + bh;
					c->w = sw - 2 * BORDERPX;
					c->h = master - 2 * BORDERPX;
					break;
				case StackRight:
					c->x = sx;
					c->y = sy + bh;
					c->w = master - 2 * BORDERPX;
					c->h = sh - bh - 2 * BORDERPX;
					break;
				}
			}
			else if((isvertical && th > bh) || (!isvertical && tw > MINW)) {
				/* tile window */
				c->x = sx;
				if(isvertical)
					c->y = sy + (i - 1) * th + bh;
				else
					c->y = sy + bh;
				if(stackpos == StackRight)
					c->x += master;
				else if(stackpos == StackBottom)
					c->y += master;
				c->w = tw - 2 * BORDERPX;
				c->h = th - 2 * BORDERPX;
				if(i + 1 == n) { /* fixes for last tile to take up rest space */
					if(isvertical)
						c->h = sh - c->y - 2 * BORDERPX;
				switch(stackpos) {
				case StackLeft:
					if(isvertical) {
						c->x = sx;
						c->y = sy + (i - 1) * th + bh;
						if(i + 1 == n)
							c->h = sh - c->y - 2 * BORDERPX;
					}
					else {
						if(stackpos == StackLeft)
							c->w = master - c->x - 2 * BORDERPX;
						else
						c->x = sx + (i - 1) * tw;
						c->y = sy + bh;
						if(i + 1 == n)
							c->w = sx + stackw - c->x - 2 * BORDERPX;
					}
					break;
				case StackBottom:
					if(isvertical) {
						c->x = sx;
						c->y = sy + master + (i - 1) * th + bh;
						if(i + 1 == n)
							c->h = sh - c->y - 2 * BORDERPX;
					}
					else {
						c->x = sx + (i - 1) * tw;
						c->y = sy + bh + master;
						if(i + 1 == n)
							c->w = sw - c->x - 2 * BORDERPX;
					}
					break;
				case StackRight:
					if(isvertical) {
						c->x = sx + master;
						c->y = sy + (i - 1) * th + bh;
						if(i + 1 == n)
							c->h = sh - c->y - 2 * BORDERPX;
					}
					else {
						c->x = sx + master + (i - 1) * tw;
						c->y = sy + bh;
						if(i + 1 == n)
							c->w = sx + stackw - c->x - 2 * BORDERPX;
					}
					break;
				}
			}
			else { /* fallback if th < bh resp. tw < MINW */
				c->x = sx;
				c->y = sy + bh;
				if(stackpos == StackRight)
					c->x += master;
				else if(stackpos == StackBottom)
					c->y += master;
				c->w = stackw - 2 * BORDERPX;
				c->h = stackh - 2 * BORDERPX;
				switch(stackpos) {
				case StackLeft:
					c->x = sx;
					c->y = sy + bh;
					break;
				case StackBottom:
					c->x = sx;
					c->y = sy + master;
					break;
				case StackRight:
					c->x = sx + master;
					c->y = sy + bh;
					break;
				}
			}
			resize(c, False, TopLeft);
			i++;

}

void
togglestackdir(Arg *arg) {
	if(arrange == dofloat)
		return;
	isvertical = !isvertical;
	arrange(NULL);
}

void
togglestackpos(Arg *arg) {
	if(arrange == dofloat)
		return;
	if(stackpos == StackBottom)
		stackpos = STACKPOS;
	else
		stackpos = StackBottom;
	updatemaster();
	arrange(NULL);
}

void
updatemaster(void) {
	master = ((stackpos == StackBottom ? sh - bh : sw) * MASTER) / 100;
}

void
view(Arg *arg) {
	unsigned int i;


	reorder();
	arrange(NULL);
}



void
zoom(Arg *arg) {

36	36		{ MODKEY, XK_j, focusnext, { 0 } }, \
37	37		{ MODKEY, XK_k, focusprev, { 0 } }, \
38	38		{ MODKEY, XK_Return, zoom, { 0 } }, \
	39	+	{ MODKEY, XK_b, togglestackpos, { 0 } }, \
	40	+	{ MODKEY, XK_d, togglestackdir, { 0 } }, \
39	41		{ MODKEY, XK_g, resizecol, { .i = 20 } }, \
40	42		{ MODKEY, XK_s, resizecol, { .i = -20 } }, \
41	43		{ MODKEY\|ShiftMask, XK_1, tag, { .i = 0 } }, \

102	102		extern const char tags[]; / all tags */
103	103		extern char stext[1024]; /* status text */
104	104		extern int bx, by, bw, bh, bmw; /* bar geometry, bar mode label width */
105		-	extern int master, screen, sx, sy, sw, sh; /* screen geometry, master width */
	105	+	extern int master, screen, sx, sy, sw, sh; /* screen geometry, master dimension*/
106	106		extern unsigned int ntags, numlockmask; /* number of tags, dynamic lock mask */
107	107		extern void (handler[LASTEvent])(XEvent ); /* event handler */
108	108		extern void (arrange)(Arg ); /* arrange function, indicates mode */

170	170		extern void focusnext(Arg arg); / focuses next visible client, arg is ignored */
171	171		extern void focusprev(Arg arg); / focuses previous visible client, arg is ignored */
172	172		extern Bool isvisible(Client c); / returns True if client is visible */
173		-	extern void resizecol(Arg arg); / resizes the master width with arg's index value */
	173	+	extern void resizecol(Arg arg); / resizes the master dimension with arg's index value */
174	174		extern void restack(void); /* restores z layers of all clients */
	175	+	extern void togglestackdir(Arg arg); / toggles stack direction */
	176	+	extern void togglestackpos(Arg arg); / toggles stack position */
175	177		extern void togglemode(Arg arg); / toggles global arrange function (dotile/dofloat) */
176	178		extern void toggleview(Arg arg); / toggles the tag with arg's index (in)visible */
	179	+	extern void updatemaster(void); /* updates master dimension */
177	180		extern void view(Arg arg); / views the tag with arg's index */
178	181		extern void viewall(Arg arg); / views all tags, arg is ignored */
179		-	extern void zoom(Arg arg); / zooms the focused client to master column, arg is ignored */
	182	+	extern void zoom(Arg arg); / zooms the focused client to master area, arg is ignored */

177	177		configure(c);
178	178		XSync(dpy, False);
179	179		if(c->isfloat) {
180		-	if(isvisible(c))
181		-	resize(c, False, TopLeft);
	180	+	resize(c, False, TopLeft);
	181	+	if(!isvisible(c))
	182	+	ban(c);
182	183		}
183	184		else
184	185		arrange(NULL);

133	133		sx = sy = 0;
134	134		sw = DisplayWidth(dpy, screen);
135	135		sh = DisplayHeight(dpy, screen);
136		-	master = ((stackpos == StackBottom ? sh - bh : sw) * MASTER) / 100;
	136	+	updatemaster();
137	137
138	138		bx = by = 0;
139	139		bw = sw;

148	148		c->h = sh - 2 * BORDERPX - bh;
149	149		}
150	150		else if(i == 0) { /* master window */
151		-	c->x = sx;
152		-	if(stackpos == StackLeft)
153		-	c->x += master;
154		-	c->y = sy + bh;
155		-	if(isvertical) {
	151	+	switch(stackpos) {
	152	+	case StackLeft:
	153	+	c->x = sx + stackw;
	154	+	c->y = sy + bh;
156	155		c->w = master - 2 * BORDERPX;
157		-	c->h = sh - 2 * BORDERPX - bh;
158		-	}
159		-	else {
160		-	c->w = sw;
	156	+	c->h = sh - bh - 2 * BORDERPX;
	157	+	break;
	158	+	case StackBottom:
	159	+	c->x = sx;
	160	+	c->y = sy + bh;
	161	+	c->w = sw - 2 * BORDERPX;
161	162		c->h = master - 2 * BORDERPX;
	163	+	break;
	164	+	case StackRight:
	165	+	c->x = sx;
	166	+	c->y = sy + bh;
	167	+	c->w = master - 2 * BORDERPX;
	168	+	c->h = sh - bh - 2 * BORDERPX;
	169	+	break;
162	170		}
163	171		}
164	172		else if((isvertical && th > bh) \|\| (!isvertical && tw > MINW)) {
165	173		/* tile window */
166		-	c->x = sx;
167		-	if(isvertical)
168		-	c->y = sy + (i - 1) * th + bh;
169		-	else
170		-	c->y = sy + bh;
171		-	if(stackpos == StackRight)
172		-	c->x += master;
173		-	else if(stackpos == StackBottom)
174		-	c->y += master;
175	174		c->w = tw - 2 * BORDERPX;
176	175		c->h = th - 2 * BORDERPX;
177		-	if(i + 1 == n) { /* fixes for last tile to take up rest space */
178		-	if(isvertical)
179		-	c->h = sh - c->y - 2 * BORDERPX;
	176	+	switch(stackpos) {
	177	+	case StackLeft:
	178	+	if(isvertical) {
	179	+	c->x = sx;
	180	+	c->y = sy + (i - 1) * th + bh;
	181	+	if(i + 1 == n)
	182	+	c->h = sh - c->y - 2 * BORDERPX;
	183	+	}
180	184		else {
181		-	if(stackpos == StackLeft)
182		-	c->w = master - c->x - 2 * BORDERPX;
183		-	else
	185	+	c->x = sx + (i - 1) * tw;
	186	+	c->y = sy + bh;
	187	+	if(i + 1 == n)
	188	+	c->w = sx + stackw - c->x - 2 * BORDERPX;
	189	+	}
	190	+	break;
	191	+	case StackBottom:
	192	+	if(isvertical) {
	193	+	c->x = sx;
	194	+	c->y = sy + master + (i - 1) * th + bh;
	195	+	if(i + 1 == n)
	196	+	c->h = sh - c->y - 2 * BORDERPX;
	197	+	}
	198	+	else {
	199	+	c->x = sx + (i - 1) * tw;
	200	+	c->y = sy + bh + master;
	201	+	if(i + 1 == n)
184	202		c->w = sw - c->x - 2 * BORDERPX;
185	203		}
	204	+	break;
	205	+	case StackRight:
	206	+	if(isvertical) {
	207	+	c->x = sx + master;
	208	+	c->y = sy + (i - 1) * th + bh;
	209	+	if(i + 1 == n)
	210	+	c->h = sh - c->y - 2 * BORDERPX;
	211	+	}
	212	+	else {
	213	+	c->x = sx + master + (i - 1) * tw;
	214	+	c->y = sy + bh;
	215	+	if(i + 1 == n)
	216	+	c->w = sx + stackw - c->x - 2 * BORDERPX;
	217	+	}
	218	+	break;
186	219		}
187	220		}
188	221		else { /* fallback if th < bh resp. tw < MINW */
189		-	c->x = sx;
190		-	c->y = sy + bh;
191		-	if(stackpos == StackRight)
192		-	c->x += master;
193		-	else if(stackpos == StackBottom)
194		-	c->y += master;
195	222		c->w = stackw - 2 * BORDERPX;
196	223		c->h = stackh - 2 * BORDERPX;
	224	+	switch(stackpos) {
	225	+	case StackLeft:
	226	+	c->x = sx;
	227	+	c->y = sy + bh;
	228	+	break;
	229	+	case StackBottom:
	230	+	c->x = sx;
	231	+	c->y = sy + master;
	232	+	break;
	233	+	case StackRight:
	234	+	c->x = sx + master;
	235	+	c->y = sy + bh;
	236	+	break;
	237	+	}
197	238		}
198	239		resize(c, False, TopLeft);
199	240		i++;

319	360		}
320	361
321	362		void
	363	+	togglestackdir(Arg *arg) {
	364	+	if(arrange == dofloat)
	365	+	return;
	366	+	isvertical = !isvertical;
	367	+	arrange(NULL);
	368	+	}
	369	+
	370	+	void
	371	+	togglestackpos(Arg *arg) {
	372	+	if(arrange == dofloat)
	373	+	return;
	374	+	if(stackpos == StackBottom)
	375	+	stackpos = STACKPOS;
	376	+	else
	377	+	stackpos = StackBottom;
	378	+	updatemaster();
	379	+	arrange(NULL);
	380	+	}
	381	+
	382	+	void
	383	+	updatemaster(void) {
	384	+	master = ((stackpos == StackBottom ? sh - bh : sw) * MASTER) / 100;
	385	+	}
	386	+
	387	+	void
322	388		view(Arg *arg) {
323	389		unsigned int i;
324	390

338	404		reorder();
339	405		arrange(NULL);
340	406		}
	407	+
	408	+
341	409
342	410		void
343	411		zoom(Arg *arg) {

30	30		{ MODKEY, XK_Tab, focusnext, { 0 } }, \
31	31		{ MODKEY\|ShiftMask, XK_Tab, focusprev, { 0 } }, \
32	32		{ MODKEY, XK_Return, zoom, { 0 } }, \
	33	+	{ MODKEY, XK_b, togglestackpos, { 0 } }, \
	34	+	{ MODKEY, XK_d, togglestackdir, { 0 } }, \
33	35		{ MODKEY, XK_g, resizecol, { .i = 20 } }, \
34	36		{ MODKEY, XK_s, resizecol, { .i = -20 } }, \
35	37		{ MODKEY\|ShiftMask, XK_1, tag, { .i = 0 } }, \