git.stevedylan.dev

keep master ratio on resizecol -> arrange 6fc8a630

Anselm R. Garbe · 2006-10-05 12:59 5 file(s) · +20 −24

config.arg.h +2 −2

	{ MODKEY,			XK_k,		focusprev,	{ 0 } }, \
	{ MODKEY,			XK_Return,	zoom,		{ 0 } }, \
	{ MODKEY,			XK_b,		togglestackpos,	{ 0 } }, \
	{ MODKEY,			XK_g,		resizecol,	{ .i = 20 } }, \
	{ MODKEY,			XK_s,		resizecol,	{ .i = -20 } }, \
	{ MODKEY,			XK_g,		resizecol,	{ .i = 1 } }, \
	{ MODKEY,			XK_s,		resizecol,	{ .i = -1 } }, \
	{ MODKEY|ShiftMask,		XK_1,		tag,		{ .i = 0 } }, \
	{ MODKEY|ShiftMask,		XK_2,		tag,		{ .i = 1 } }, \
	{ MODKEY|ShiftMask,		XK_3,		tag,		{ .i = 2 } }, \

config.default.h +2 −2

	{ MODKEY|ShiftMask,		XK_Tab,		focusprev,	{ 0 } }, \
	{ MODKEY,			XK_Return,	zoom,		{ 0 } }, \
	{ MODKEY,			XK_b,		togglestackpos,	{ 0 } }, \
	{ MODKEY,			XK_g,		resizecol,	{ .i = 20 } }, \
	{ MODKEY,			XK_s,		resizecol,	{ .i = -20 } }, \
	{ MODKEY,			XK_g,		resizecol,	{ .i = 1 } }, \
	{ MODKEY,			XK_s,		resizecol,	{ .i = -1 } }, \
	{ MODKEY|ShiftMask,		XK_1,		tag,		{ .i = 0 } }, \
	{ MODKEY|ShiftMask,		XK_2,		tag,		{ .i = 1 } }, \
	{ MODKEY|ShiftMask,		XK_3,		tag,		{ .i = 2 } }, \

dwm.h +3 −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 dimension*/
extern unsigned int ntags, numlockmask;		/* number of tags, dynamic lock mask */
extern int screen, sx, sy, sw, sh;		/* screen geometry */
extern unsigned int master, ntags, numlockmask;	/* master percent, number of tags, dynamic lock mask */
extern void (*handler[LASTEvent])(XEvent *);	/* event handler */
extern void (*arrange)(Arg *);			/* arrange function, indicates mode  */
extern Atom wmatom[WMLast], netatom[NetLast];

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 dimension with arg's index value */
extern void resizecol(Arg *arg);		/* resizes the master percent with arg's index value */
extern void restack(void);			/* restores z layers of all clients */
extern void togglestackpos(Arg *arg);		/* toggles stack position */
extern void togglemode(Arg *arg);		/* toggles global arrange function (dotile/dofloat) */

main.c +3 −3


char stext[1024];
Bool *seltag;
int bx, by, bw, bh, bmw, master, screen, sx, sy, sw, sh;
unsigned int ntags, numlockmask;
int bx, by, bw, bh, bmw, masterd, screen, sx, sy, sw, sh;
unsigned int master, ntags, numlockmask;
Atom wmatom[WMLast], netatom[NetLast];
Bool running = True;
Bool issel = True;

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

	bx = by = 0;
	bw = sw;

view.c +10 −14

 */
#include "dwm.h"

#define MINDIM			100

/* static */

static Client *

void
dotile(Arg *arg) {
	int i, n, stackw, stackh, tw, th;
	unsigned int md = ((stackpos == StackBottom ? sh - bh : sw) * master) / 100;
	Client *c;

	for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))


	if(stackpos == StackBottom) {
		stackw = sw;
		stackh = sh - bh - master;
		stackh = sh - bh - md;
	}
	else {
		stackw = sw - master;
		stackw = sw - md;
		stackh = sh - bh;
	}


				switch(stackpos) {
				case StackLeft:
				case StackRight:
					c->w = master - 2 * BORDERPX;
					c->w = md - 2 * BORDERPX;
					c->h = sh - bh - 2 * BORDERPX;
					break;
				case StackBottom:
					c->w = sw - 2 * BORDERPX;
					c->h = master - 2 * BORDERPX;
					c->h = md - 2 * BORDERPX;
					break;
				}
			}
			else {  /* tile window */
				if(stackpos == StackRight)
					c->x += master;
					c->x += md;
				if(th > bh) {
					switch(stackpos) {
					case StackLeft:

							c->h = sh - c->y - 2 * BORDERPX;
						break;
					case StackBottom:
						c->y = sy + master + (i - 1) * th + bh;
						c->y = sy + md + (i - 1) * th + bh;
						if(i + 1 == n)
							c->h = sh - c->y - 2 * BORDERPX;
						break;

				}
				else { /* fallback if th < bh */
					if(stackpos == StackBottom)
						c->y += master;
						c->y += md;
					c->w = stackw - 2 * BORDERPX;
					c->h = stackh - 2 * BORDERPX;
				}


void
resizecol(Arg *arg) {
	int s;
	unsigned int n;
	Client *c;


	if(!sel || sel->isfloat || n < 2 || (arrange == dofloat))
		return;

	s = stackpos == StackBottom ? sh - bh : sw;
	if(sel == getnext(clients)) {
		if(master + arg->i > s - MINDIM || master + arg->i < MINDIM)
		if(master + arg->i > 95 || master + arg->i < 5)
			return;
		master += arg->i;
	}
	else {
		if(master - arg->i > s - MINDIM || master - arg->i < MINDIM)
		if(master - arg->i > 95 || master - arg->i < 5)
			return;
		master -= arg->i;
	}

		stackpos = STACKPOS;
	else
		stackpos = StackBottom;
	master = ((stackpos == StackBottom ? sh - bh : sw) * MASTER) / 100;
	arrange(NULL);
}


37	37		{ MODKEY, XK_k, focusprev, { 0 } }, \
38	38		{ MODKEY, XK_Return, zoom, { 0 } }, \
39	39		{ MODKEY, XK_b, togglestackpos, { 0 } }, \
40		-	{ MODKEY, XK_g, resizecol, { .i = 20 } }, \
41		-	{ MODKEY, XK_s, resizecol, { .i = -20 } }, \
	40	+	{ MODKEY, XK_g, resizecol, { .i = 1 } }, \
	41	+	{ MODKEY, XK_s, resizecol, { .i = -1 } }, \
42	42		{ MODKEY\|ShiftMask, XK_1, tag, { .i = 0 } }, \
43	43		{ MODKEY\|ShiftMask, XK_2, tag, { .i = 1 } }, \
44	44		{ MODKEY\|ShiftMask, XK_3, tag, { .i = 2 } }, \

31	31		{ MODKEY\|ShiftMask, XK_Tab, focusprev, { 0 } }, \
32	32		{ MODKEY, XK_Return, zoom, { 0 } }, \
33	33		{ MODKEY, XK_b, togglestackpos, { 0 } }, \
34		-	{ MODKEY, XK_g, resizecol, { .i = 20 } }, \
35		-	{ MODKEY, XK_s, resizecol, { .i = -20 } }, \
	34	+	{ MODKEY, XK_g, resizecol, { .i = 1 } }, \
	35	+	{ MODKEY, XK_s, resizecol, { .i = -1 } }, \
36	36		{ MODKEY\|ShiftMask, XK_1, tag, { .i = 0 } }, \
37	37		{ MODKEY\|ShiftMask, XK_2, tag, { .i = 1 } }, \
38	38		{ MODKEY\|ShiftMask, XK_3, tag, { .i = 2 } }, \

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

168	168		extern void focusnext(Arg arg); / focuses next visible client, arg is ignored */
169	169		extern void focusprev(Arg arg); / focuses previous visible client, arg is ignored */
170	170		extern Bool isvisible(Client c); / returns True if client is visible */
171		-	extern void resizecol(Arg arg); / resizes the master dimension with arg's index value */
	171	+	extern void resizecol(Arg arg); / resizes the master percent with arg's index value */
172	172		extern void restack(void); /* restores z layers of all clients */
173	173		extern void togglestackpos(Arg arg); / toggles stack position */
174	174		extern void togglemode(Arg arg); / toggles global arrange function (dotile/dofloat) */

19	19
20	20		char stext[1024];
21	21		Bool *seltag;
22		-	int bx, by, bw, bh, bmw, master, screen, sx, sy, sw, sh;
23		-	unsigned int ntags, numlockmask;
	22	+	int bx, by, bw, bh, bmw, masterd, screen, sx, sy, sw, sh;
	23	+	unsigned int master, ntags, numlockmask;
24	24		Atom wmatom[WMLast], netatom[NetLast];
25	25		Bool running = True;
26	26		Bool issel = True;

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

4	4		*/
5	5		#include "dwm.h"
6	6
7		-	#define MINDIM 100
8		-
9	7		/* static */
10	8
11	9		static Client *

106	104		void
107	105		dotile(Arg *arg) {
108	106		int i, n, stackw, stackh, tw, th;
	107	+	unsigned int md = ((stackpos == StackBottom ? sh - bh : sw) * master) / 100;
109	108		Client *c;
110	109
111	110		for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))

113	112
114	113		if(stackpos == StackBottom) {
115	114		stackw = sw;
116		-	stackh = sh - bh - master;
	115	+	stackh = sh - bh - md;
117	116		}
118	117		else {
119		-	stackw = sw - master;
	118	+	stackw = sw - md;
120	119		stackh = sh - bh;
121	120		}
122	121

145	144		switch(stackpos) {
146	145		case StackLeft:
147	146		case StackRight:
148		-	c->w = master - 2 * BORDERPX;
	147	+	c->w = md - 2 * BORDERPX;
149	148		c->h = sh - bh - 2 * BORDERPX;
150	149		break;
151	150		case StackBottom:
152	151		c->w = sw - 2 * BORDERPX;
153		-	c->h = master - 2 * BORDERPX;
	152	+	c->h = md - 2 * BORDERPX;
154	153		break;
155	154		}
156	155		}
157	156		else { /* tile window */
158	157		if(stackpos == StackRight)
159		-	c->x += master;
	158	+	c->x += md;
160	159		if(th > bh) {
161	160		switch(stackpos) {
162	161		case StackLeft:

166	165		c->h = sh - c->y - 2 * BORDERPX;
167	166		break;
168	167		case StackBottom:
169		-	c->y = sy + master + (i - 1) * th + bh;
	168	+	c->y = sy + md + (i - 1) * th + bh;
170	169		if(i + 1 == n)
171	170		c->h = sh - c->y - 2 * BORDERPX;
172	171		break;

176	175		}
177	176		else { /* fallback if th < bh */
178	177		if(stackpos == StackBottom)
179		-	c->y += master;
	178	+	c->y += md;
180	179		c->w = stackw - 2 * BORDERPX;
181	180		c->h = stackh - 2 * BORDERPX;
182	181		}

238	237
239	238		void
240	239		resizecol(Arg *arg) {
241		-	int s;
242	240		unsigned int n;
243	241		Client *c;
244	242

248	246		if(!sel \|\| sel->isfloat \|\| n < 2 \|\| (arrange == dofloat))
249	247		return;
250	248
251		-	s = stackpos == StackBottom ? sh - bh : sw;
252	249		if(sel == getnext(clients)) {
253		-	if(master + arg->i > s - MINDIM \|\| master + arg->i < MINDIM)
	250	+	if(master + arg->i > 95 \|\| master + arg->i < 5)
254	251		return;
255	252		master += arg->i;
256	253		}
257	254		else {
258		-	if(master - arg->i > s - MINDIM \|\| master - arg->i < MINDIM)
	255	+	if(master - arg->i > 95 \|\| master - arg->i < 5)
259	256		return;
260	257		master -= arg->i;
261	258		}

321	318		stackpos = STACKPOS;
322	319		else
323	320		stackpos = StackBottom;
324		-	master = ((stackpos == StackBottom ? sh - bh : sw) * MASTER) / 100;
325	321		arrange(NULL);
326	322		}
327	323