Mercurial Mercurial > dwm / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
layout.c
changeset 813 0ed770c96e51
parent 799 30ec8b96a7f6
child 815 aca93bbd6e8d
equal deleted inserted replaced
812:8992a53a0d6a 813:0ed770c96e51 
     1 /* (C)opyright MMVI-MMVII Anselm R. Garbe <garbeam at gmail dot com>
 
     1 /* (C)opyright MMVI-MMVII Anselm R. Garbe <garbeam at gmail dot com>
 
     2  * See LICENSE file for license details.
 
     2  * See LICENSE file for license details.
 
     3  */
 
     3  */
 
     4 #include "dwm.h"
 
     4 #include "dwm.h"
 
     5 
     5 
     6 unsigned int master = MASTER;
 
       
     7 unsigned int nmaster = NMASTER;
 
       
     8 unsigned int blw = 0;
 
     6 unsigned int blw = 0;
 
     9 Layout *lt = NULL;
 
     7 Layout *lt = NULL;
 
    10 
     8 
    11 /* static */
 
     9 /* static */
 
    12 
    10 
    13 static unsigned int nlayouts = 0;
 
    11 static unsigned int nlayouts = 0;
 
       
    12 static unsigned int masterw = MASTERWIDTH;
 
       
    13 static unsigned int nmaster = NMASTER;
 
    14 
    14 
    15 static void
 
    15 static void
 
    16 tile(void) {
 
    16 tile(void) {
 
    17 	unsigned int i, n, nx, ny, nw, nh, mw, mh, tw, th;
 
    17 	unsigned int i, n, nx, ny, nw, nh, mw, mh, tw, th;
 
    18 	Client *c;
 
    18 	Client *c;
 
    19 
    19 
    20 	for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))
 
    20 	for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))
 
    21 		n++;
 
    21 		n++;
 
    22 	/* window geoms */
 
    22 	/* window geoms */
 
    23 	mh = (n > nmaster) ? wah / nmaster : wah / (n > 0 ? n : 1);
 
    23 	mh = (n > nmaster) ? wah / nmaster : wah / (n > 0 ? n : 1);
 
    24 	mw = (n > nmaster) ? (waw * master) / 1000 : waw;
 
    24 	mw = (n > nmaster) ? (waw * masterw) / 1000 : waw;
 
    25 	th = (n > nmaster) ? wah / (n - nmaster) : 0;
 
    25 	th = (n > nmaster) ? wah / (n - nmaster) : 0;
 
    26 	tw = waw - mw;
 
    26 	tw = waw - mw;
 
    27 
    27 
    28 	for(i = 0, c = clients; c; c = c->next)
 
    28 	for(i = 0, c = clients; c; c = c->next)
 
    29 		if(isvisible(c)) {
 
    29 		if(isvisible(c)) {
 
    67 LAYOUTS
 
    67 LAYOUTS
 
    68 
    68 
    69 /* extern */
 
    69 /* extern */
 
    70 
    70 
    71 void
 
    71 void
 
    72 focusnext(Arg *arg) {
 
    72 focusnext(Arg arg) {
 
    73 	Client *c;
 
    73 	Client *c;
 
    74    
    74    
    75 	if(!sel)
 
    75 	if(!sel)
 
    76 		return;
 
    76 		return;
 
    77 	for(c = sel->next; c && !isvisible(c); c = c->next);
 
    77 	for(c = sel->next; c && !isvisible(c); c = c->next);
 
    82 		restack();
 
    82 		restack();
 
    83 	}
 
    83 	}
 
    84 }
 
    84 }
 
    85 
    85 
    86 void
 
    86 void
 
    87 focusprev(Arg *arg) {
 
    87 focusprev(Arg arg) {
 
    88 	Client *c;
 
    88 	Client *c;
 
    89 
    89 
    90 	if(!sel)
 
    90 	if(!sel)
 
    91 		return;
 
    91 		return;
 
    92 	for(c = sel->prev; c && !isvisible(c); c = c->prev);
 
    92 	for(c = sel->prev; c && !isvisible(c); c = c->prev);
 
    99 		restack();
 
    99 		restack();
 
   100 	}
 
   100 	}
 
   101 }
 
   101 }
 
   102 
   102 
   103 void
 
   103 void
 
   104 incnmaster(Arg *arg) {
 
   104 incmasterw(Arg arg) {
 
   105 	if((lt->arrange != tile) || (nmaster + arg->i < 1)
 
   105 	if(lt->arrange != tile)
 
   106 	|| (wah / (nmaster + arg->i) <= 2 * BORDERPX))
 
   106 		return;
 
   107 		return;
 
   107 	if(arg.i == 0)
 
   108 	nmaster += arg->i;
 
   108 		masterw = MASTERWIDTH;
 
       
   109 	else {
 
       
   110 		if(waw * (masterw + arg.i) / 1000 >= waw - 2 * BORDERPX
 
       
   111 		|| waw * (masterw + arg.i) / 1000 <= 2 * BORDERPX)
 
       
   112 			return;
 
       
   113 		masterw += arg.i;
 
       
   114 	}
 
       
   115 	lt->arrange();
 
       
   116 }
 
       
   117 
       
   118 void
 
       
   119 incnmaster(Arg arg) {
 
       
   120 	if((lt->arrange != tile) || (nmaster + arg.i < 1)
 
       
   121 	|| (wah / (nmaster + arg.i) <= 2 * BORDERPX))
 
       
   122 		return;
 
       
   123 	nmaster += arg.i;
 
   109 	if(sel)
 
   124 	if(sel)
 
   110 		lt->arrange();
 
   125 		lt->arrange();
 
   111 	else
 
   126 	else
 
   112 		drawstatus();
 
   127 		drawstatus();
 
   113 }
 
   128 }
 
   127 
   142 
   128 Client *
 
   143 Client *
 
   129 nexttiled(Client *c) {
 
   144 nexttiled(Client *c) {
 
   130 	for(; c && (c->isversatile || !isvisible(c)); c = c->next);
 
   145 	for(; c && (c->isversatile || !isvisible(c)); c = c->next);
 
   131 	return c;
 
   146 	return c;
 
   132 }
 
       
   133 
       
   134 void
 
       
   135 resizemaster(Arg *arg) {
 
       
   136 	if(lt->arrange != tile)
 
       
   137 		return;
 
       
   138 	if(arg->i == 0)
 
       
   139 		master = MASTER;
 
       
   140 	else {
 
       
   141 		if(waw * (master + arg->i) / 1000 >= waw - 2 * BORDERPX
 
       
   142 		|| waw * (master + arg->i) / 1000 <= 2 * BORDERPX)
 
       
   143 			return;
 
       
   144 		master += arg->i;
 
       
   145 	}
 
       
   146 	lt->arrange();
 
       
   147 }
 
   147 }
 
   148 
   148 
   149 void
 
   149 void
 
   150 restack(void) {
 
   150 restack(void) {
 
   151 	Client *c;
 
   151 	Client *c;
 
   168 	XSync(dpy, False);
 
   168 	XSync(dpy, False);
 
   169 	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
 
   169 	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
 
   170 }
 
   170 }
 
   171 
   171 
   172 void
 
   172 void
 
   173 setlayout(Arg *arg) {
 
   173 setlayout(Arg arg) {
 
   174 	unsigned int i;
 
   174 	unsigned int i;
 
   175 
   175 
   176 	if(arg->i == -1) {
 
   176 	if(arg.i == -1) {
 
   177 		for(i = 0; i < nlayouts && lt != &layout[i]; i++);
 
   177 		for(i = 0; i < nlayouts && lt != &layout[i]; i++);
 
   178 		if(i == nlayouts - 1)
 
   178 		if(i == nlayouts - 1)
 
   179 			lt = &layout[0];
 
   179 			lt = &layout[0];
 
   180 		else
 
   180 		else
 
   181 			lt = &layout[++i];
 
   181 			lt = &layout[++i];
 
   182 	}
 
   182 	}
 
   183 	else {
 
   183 	else {
 
   184 		if(arg->i < 0 || arg->i >= nlayouts)
 
   184 		if(arg.i < 0 || arg.i >= nlayouts)
 
   185 			return;
 
   185 			return;
 
   186 		lt = &layout[arg->i];
 
   186 		lt = &layout[arg.i];
 
   187 	}
 
   187 	}
 
   188 	if(sel)
 
   188 	if(sel)
 
   189 		lt->arrange();
 
   189 		lt->arrange();
 
   190 	else
 
   190 	else
 
   191 		drawstatus();
 
   191 		drawstatus();
 
       
   192 }
 
       
   193 
       
   194 void
 
       
   195 togglemax(Arg arg) {
 
       
   196 	XEvent ev;
 
       
   197 
       
   198 	if(!sel || !sel->isversatile || sel->isfixed || lt->arrange != versatile)
 
       
   199 		return;
 
       
   200 	if((sel->ismax = !sel->ismax)) {
 
       
   201 		sel->rx = sel->x;
 
       
   202 		sel->ry = sel->y;
 
       
   203 		sel->rw = sel->w;
 
       
   204 		sel->rh = sel->h;
 
       
   205 		resize(sel, wax, way, waw - 2 * BORDERPX, wah - 2 * BORDERPX, True);
 
       
   206 	}
 
       
   207 	else
 
       
   208 		resize(sel, sel->rx, sel->ry, sel->rw, sel->rh, True);
 
       
   209 	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
 
   192 }
 
   210 }
 
   193 
   211 
   194 void
 
   212 void
 
   195 versatile(void) {
 
   213 versatile(void) {
 
   196 	Client *c;
 
   214 	Client *c;
 
   211 		for(c = stack; c && !isvisible(c); c = c->snext);
 
   229 		for(c = stack; c && !isvisible(c); c = c->snext);
 
   212 		focus(c);
 
   230 		focus(c);
 
   213 	}
 
   231 	}
 
   214 	restack();
 
   232 	restack();
 
   215 }
 
   233 }
 
       
   234 
       
   235 void
 
       
   236 zoom(Arg arg) {
 
       
   237 	unsigned int n;
 
       
   238 	Client *c;
 
       
   239 
       
   240 	if(!sel || lt->arrange != tile || sel->isversatile)
 
       
   241 		return;
 
       
   242 	for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))
 
       
   243 		n++;
 
       
   244 	if((c = sel) == nexttiled(clients))
 
       
   245 		if(!(c = nexttiled(c->next)))
 
       
   246 			return;
 
       
   247 	detach(c);
 
       
   248 	attach(c);
 
       
   249 	focus(c);
 
       
   250 	lt->arrange();
 
       
   251 }
dwm