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.
view.c
changeset 508 ede48935f2b3
parent 507 2824b5d0f0f0
child 510 0dfa6b752aed
equal deleted inserted replaced
507:2824b5d0f0f0 508:ede48935f2b3 
   146 				c->y = sy + bh;
 
   146 				c->y = sy + bh;
 
   147 				c->w = sw - 2 * BORDERPX;
 
   147 				c->w = sw - 2 * BORDERPX;
 
   148 				c->h = sh - 2 * BORDERPX - bh;
 
   148 				c->h = sh - 2 * BORDERPX - bh;
 
   149 			}
 
   149 			}
 
   150 			else if(i == 0) { /* master window */
 
   150 			else if(i == 0) { /* master window */
 
   151 				c->x = sx;
 
   151 				switch(stackpos) {
 
   152 				if(stackpos == StackLeft)
 
   152 				case StackLeft:
 
   153 					c->x += master;
 
   153 					c->x = sx + stackw;
 
   154 				c->y = sy + bh;
 
   154 					c->y = sy + bh;
 
   155 				if(isvertical) {
 
       
   156 					c->w = master - 2 * BORDERPX;
 
   155 					c->w = master - 2 * BORDERPX;
 
   157 					c->h = sh - 2 * BORDERPX - bh;
 
   156 					c->h = sh - bh - 2 * BORDERPX;
 
   158 				}
 
   157 					break;
 
   159 				else {
 
   158 				case StackBottom:
 
   160 					c->w = sw;
 
   159 					c->x = sx;
 
       
   160 					c->y = sy + bh;
 
       
   161 					c->w = sw - 2 * BORDERPX;
 
   161 					c->h = master - 2 * BORDERPX;
 
   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 			else if((isvertical && th > bh) || (!isvertical && tw > MINW)) {
 
   172 			else if((isvertical && th > bh) || (!isvertical && tw > MINW)) {
 
   165 				/* tile window */
 
   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 				c->w = tw - 2 * BORDERPX;
 
   174 				c->w = tw - 2 * BORDERPX;
 
   176 				c->h = th - 2 * BORDERPX;
 
   175 				c->h = th - 2 * BORDERPX;
 
   177 				if(i + 1 == n) { /* fixes for last tile to take up rest space */
 
   176 				switch(stackpos) {
 
   178 					if(isvertical)
 
   177 				case StackLeft:
 
   179 						c->h = sh - c->y - 2 * BORDERPX;
 
   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 					else {
 
   184 					else {
 
   181 						if(stackpos == StackLeft)
 
   185 						c->x = sx + (i - 1) * tw;
 
   182 							c->w = master - c->x - 2 * BORDERPX;
 
   186 						c->y = sy + bh;
 
   183 						else
 
   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 							c->w = sw - c->x - 2 * BORDERPX;
 
   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 			else { /* fallback if th < bh resp. tw < MINW */
 
   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 				c->w = stackw - 2 * BORDERPX;
 
   222 				c->w = stackw - 2 * BORDERPX;
 
   196 				c->h = stackh - 2 * BORDERPX;
 
   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 			resize(c, False, TopLeft);
 
   239 			resize(c, False, TopLeft);
 
   199 			i++;
 
   240 			i++;
 
   200 		}
 
   241 		}
 
   201 		else
 
   242 		else
 
   317 	reorder();
 
   358 	reorder();
 
   318 	arrange(NULL);
 
   359 	arrange(NULL);
 
   319 }
 
   360 }
 
   320 
   361 
   321 void
 
   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 view(Arg *arg) {
 
   388 view(Arg *arg) {
 
   323 	unsigned int i;
 
   389 	unsigned int i;
 
   324 
   390 
   325 	for(i = 0; i < ntags; i++)
 
   391 	for(i = 0; i < ntags; i++)
 
   326 		seltag[i] = False;
 
   392 		seltag[i] = False;
 
   336 	for(i = 0; i < ntags; i++)
 
   402 	for(i = 0; i < ntags; i++)
 
   337 		seltag[i] = True;
 
   403 		seltag[i] = True;
 
   338 	reorder();
 
   404 	reorder();
 
   339 	arrange(NULL);
 
   405 	arrange(NULL);
 
   340 }
 
   406 }
 
       
   407 
       
   408 
   341 
   409 
   342 void
 
   410 void
 
   343 zoom(Arg *arg) {
 
   411 zoom(Arg *arg) {
 
   344 	unsigned int n;
 
   412 	unsigned int n;
 
   345 	Client *c;
 
   413 	Client *c;
dwm